/* $Header: pneu_keys.c,v 2.2 01/10/02 10:28:01 przybyls Exp $ */

/***********************************************************************/
/*                                                                     */
/*                  Copyright Hewlett-Packard Co. 1991                 */
/*                                                                     */
/***********************************************************************/

/***********************************************************************/
/* MODULE NAME:                                                        */
/* ============                                                        */
/*                                                                     */
/* Author:                                                             */
/*                                                                     */
/* MODULE PURPOSE:                                                     */
/*                                                                     */
/*                                                                     */
/*                                                                     */
/*                                                                     */
/***********************************************************************/


/*****************************/
/*   GLOBAL INCLUDE FILES    */
/*****************************/

#include  <typedefs.h>
#include  <p_wkfile.h>
#include  <wkfile.h>
#include  <ramps.h>
#include  <zone_config.h>
#include  <config.h>
#include  <zone_status.h>
#include  <p_status.h>
#include  <status.h>
#include  <keyboard.h>
#include  <error.h>
#include  <display.h>
#include  <stddef.h>
#include  <list_mgmt.h>
#include  <pcb_defs.h>
#include  <math.h>
#include  <512.h>
#include  <run_ui.h>
#include  <exception.h>
#include  <p_150.h>
#include  <sampler.h>



/*****************************/
/*   LOCAL INCLUDE FILES     */
/*****************************/

#include "proto.h"
#include "p_tcomp.h"

#define LAST_INLET_TYPE 16             /* VOLATILES */
#define LAST_DET_TYPE 12               /* LDID      */

/*****************************/
/*   GLOBAL VARIABLES        */
/*****************************/


/*****************************/
/*   STATIC VARIABLES        */
/*****************************/


/*****************************/
/*   EXTERNAL VARIABLES      */
/*****************************/


/*****************************/
/*   LOCAL DEFINES           */
/*****************************/


extern BIT8    Pneu_Keys_Enabled;    /* kbdtask.c */
extern const   SETPT_TBL_ENTRY Eeprom_Editor_Tbl[];
extern U_INT16 PF_Start;

/*
extern U_INT16 BDet_Switches;
*/

/*****************************/
/*   IMPLEMENT SECTION       */
/*****************************/

/**begin_proto**/

/*#pragma  SECTION PROG=rom3*/

/**end_proto**/


void InitEEPROM( U_INT8 module, U_INT8 type, U_INT8 range )
{
   U_INT16 rnge;
   U_INT16 scale;

   if (( module == FRNT_INLET_MODULE_NUMBER ) ||
       ( module == BACK_INLET_MODULE_NUMBER ))
   {
        switch ( range )
        {
            default:
            case 0:  rnge=RANGE_INLET_100PSI;scale=SCALE_INLET_100PSI; break;
            case 1:  rnge=RANGE_INLET_15PSI ;scale=SCALE_INLET_15PSI ; break;
            case 2:  rnge=RANGE_INLET_150PSI;scale=SCALE_INLET_150PSI; break;
        }
        Prog_Result = InitInletEEPROM( module, type%(LAST_INLET_TYPE+1), rnge, scale, 0,0,0);
   }
   else if (( module == FRNT_DETECTOR_MODULE_NUMBER ) ||
            ( module == BACK_DETECTOR_MODULE_NUMBER ))
   {
        switch ( type )
        {
            case  0:  type = (U_INT8)EPC_FID;   break;
            case  1:  type = (U_INT8)EPC_TCD;   break;
            case  2:  type = (U_INT8)EPC_NPD;   break;
            case  3:  type = (U_INT8)EPC_ECD;   break;
            case  4:  type = (U_INT8)EPC_FPD;   break;
            case  5:  type = (U_INT8)MAN_FID;   break;
            case  6:  type = (U_INT8)MAN_TCD;   break;
            case  7:  type = (U_INT8)MAN_NPD;   break;
            case  8:  type = (U_INT8)MAN_ECD;   break;
            case  9:  type = (U_INT8)MAN_FPD;   break;
            case 10:  type = (U_INT8)EPC_uECD;  break;
            case 11:  type = (U_INT8)EPC_uECD2; break;
            case 12:  type = (U_INT8)EPC_LDID;  break;
        }
        Prog_Result = InitDetEEPROM ( module, type, (range==0)? 0xa854: 0x3274, (range==0)? 0xa0: 0x50,0,0,0 );
   }
   else if ( module == PNEU_AUX_MODULE_NUMBER )
   {
        Prog_Result = InitAuxEEPROM ( module, type, (range==0)? 0xa854: 0x3274, (range==0)? 0xa0: 0x50,0,0,0 );
   }
}

/***********************************************************************/
/* FUNCTION:                                                           */
/* ========                                                            */
/*                                                                     */
/* PURPOSE:                                                            */
/*                                                                     */
/* RETURNED VALUE:                                                     */
/*                                                                     */
/* GLOBALS USED:                                                       */
/*                                                                     */
/* CALLS:                                                              */
/*                                                                     */
/* LIMITATIONS:                                                        */
/*                                                                     */
/***********************************************************************/
/**begin_proto**/

void InitPneuKeys( void )

/**end_proto**/
{

   Which_Line_Active = 0;
   Buffer_Number = 0;
   Prog_Result = TRUE;

   if ( ! Initialization_Complete )
   {
        Super_Wizard = TRUE;
        Object = Blessed;
        PneuFakeDisplay();
   }
   else if ( PneuKeyShortcutEnabled() )
   {
       Object = Blessed;
       Super_Wizard = TRUE;
   }
   else
   {
       Super_Wizard = FALSE;
       Object = Wizard;
   }


}


/***********************************************************************/
/* FUNCTION:                                                           */
/* ========                                                            */
/*                                                                     */
/* PURPOSE:                                                            */
/*                                                                     */
/* RETURNED VALUE:                                                     */
/*                                                                     */
/* GLOBALS USED:                                                       */
/*                                                                     */
/* CALLS:                                                              */
/*                                                                     */
/* LIMITATIONS:                                                        */
/*                                                                     */
/***********************************************************************/


void FormatHex ( U_INT32  num, BIT8 *string )

{
    U_INT8 digit;
    INT8   i;
    BIT8   *pointer;

    pointer = string+7;

    for ( i = 0 ; i < 8 ; i++ )
    {
        digit = num % 16;
        num   = num / 16;

        if ( digit <= 9 ) *pointer-- = digit + 0x30;
        else              *pointer-- = digit + 0x61 - 10;

        if ( num == 0 ) break;
    }

}



void FormatHexHalfWord ( U_INT16  num, BIT8 *string )

{
    U_INT8 digit;
    INT8   i;
    BIT8   *pointer;

    pointer = string+3;

    for ( i = 0 ; i < 4 ; i++ )
    {
        digit = num % 16;
        num   = num / 16;

        if ( digit <= 9 ) *pointer-- = digit + 0x30;
        else              *pointer-- = digit + 0x61 - 10;
    }

}



void FakeTempFormat ( U_INT16  num, BIT8 *string )

{
    U_INT16 decimal;
    U_INT16 whole;
    U_INT8 digit;
    BIT8   *pointer;
    INT8   i;

    pointer = string+6;

    decimal = num & 0x002f;
    whole   = num >> 6;

    decimal = decimal * 100 / 64;


    for ( i = 0 ; i < 2 ; i++ )
    {
        digit   = decimal % 10;
        decimal = decimal / 10;

        *pointer-- = digit + 0x30;
    }

    *pointer-- = '.';

    for ( i = 0 ; i < 3 ; i++ )
    {
        digit = whole % 10;
        whole = whole / 10;

        *pointer-- = digit + 0x30;

        if ( whole == 0 ) break;
    }


}



/**begin_proto**/

void FakeRealFormat ( INT32  num, U_INT32 scale, BIT8 *string )

/**end_proto**/
{
    U_INT16 decimal;
    U_INT16 whole;
    U_INT8  digit;
    BIT8    *pointer;
    INT8    i;
    BIT8    negative;
    U_INT16 frac_digits;
    U_INT16 whole_digits;

    if ( num < 0 )
    {
          negative = TRUE;
          num = -num;
    }
    else  negative = FALSE;

    pointer = string+6;

    decimal = (U_INT32)num % scale;
    whole   = (U_INT32)num / scale;

    switch ( scale )
    {
       case       1: frac_digits = 0; whole_digits = 7; break;
       case      10: frac_digits = 1; whole_digits = 6; break;
       case     100: frac_digits = 2; whole_digits = 5; break;
       case    1000: frac_digits = 3; whole_digits = 4; break;
       case   10000: frac_digits = 4; whole_digits = 3; break;
       case  100000: frac_digits = 5; whole_digits = 2; break;
       case 1000000: frac_digits = 6; whole_digits = 1; break;
       default:    frac_digits = 1; whole_digits = 6;
    }

    for ( i = 0 ; i < frac_digits ; i++ )
    {
        digit   = decimal % 10;
        decimal = decimal / 10;

        *pointer-- = digit + 0x30;
    }

    *pointer-- = '.';

    for ( i = 0 ; i < whole_digits ; i++ )
    {
        digit = whole % 10;
        whole = whole / 10;

        *pointer-- = digit + 0x30;

        if ( whole == 0 ) break;
    }

    if ( negative ) *pointer-- = '-';
}


/**begin_proto**/

void FakeIntFormat ( U_INT16  num, BIT8 *string )

/**end_proto**/

{
    U_INT8 digit;
    BIT8   *pointer;
    INT8   i;

    pointer = string+6;

    for ( i = 0 ; i < 6 ; i++ )
    {
        digit = num % 10;
        num   = num / 10;

        *pointer-- = digit + 0x30;

        if ( num == 0 ) break;
    }
}


void FakeNumFormat ( INT16  num, BIT8 *string )

{
    U_INT8 digit;
    BIT8   *pointer;
    INT8   i;
    BIT8   neg;

    if ( num < 0 )
    {
        neg = 1;
        num = -num;
    }
    else
    {
        neg = 0;
    }

    pointer = string;

    for ( i = 0 ; i < 6 ; i++ )
    {
        digit = num % 10;
        num   = num / 10;

        *pointer-- = digit + 0x30;

        if ( num == 0 ) break;
    }

    if ( neg ) *pointer-- = '-';
}


/**begin_proto**/

void BuildStringImage( BIT8 *line1, BIT8 *line2, BIT8 *line3, BIT8 *line4 )

/**end_proto**/
{

     U_INT8  index;
     BIT8 Pneu_Display_Image[85];

     for ( index = 0 ; index < 21 ; index++)
     {
         Pneu_Display_Image[index] = *(line1+index);
         Pneu_Display_Image[21+index] = *(line2+index);
         Pneu_Display_Image[42+index] = *(line3+index);
         Pneu_Display_Image[63+index] = *(line4+index);
     }

     switch ( Which_Line_Active )
     {
         case 0: Pneu_Display_Image[19] = '<';
                 break;
         case 1: Pneu_Display_Image[40] = '<';
                 break;
         case 2: Pneu_Display_Image[61] = '<';
                 break;
         case 3: Pneu_Display_Image[82] = '<';
                 break;
     }


     Pneu_Display_Image[84] = 0;  /* add a null terminator */

     DisplayRamString ( Pneu_Display_Image );
}



void StrCopyParm ( BIT8 *Parm, BIT8 *Dest )
{
   INT8 i;
   INT8 parm_len;

   for ( i = 0 ; i< 20; i++ ) if ( *(Parm+i) == '\0' ) { break; }

   parm_len = i;

   for ( i = 0 ; i < parm_len ; i++ ) *(Dest+19-parm_len+i) = *(Parm+i);
}

/**begin_proto**/

void StrCopy ( BIT8 *Source, BIT8 *Dest)

/**end_proto**/
{

    INT8 i;

    for ( i = 0 ; i < 21 ; i++ ) *(Dest+i) = *(Source+i);

}


/***********************************************************************/
/* FUNCTION:                                                           */
/* ========                                                            */
/*                                                                     */
/* PURPOSE:                                                            */
/*                                                                     */
/* RETURNED VALUE:                                                     */
/*                                                                     */
/* GLOBALS USED:                                                       */
/*                                                                     */
/* CALLS:                                                              */
/*                                                                     */
/* LIMITATIONS:                                                        */
/*                                                                     */
/***********************************************************************/
/**begin_proto**/

void Pneu_Keyboard (KEYCODE  Key )

/**end_proto**/
{

     BIT8  number;
     U_INT16 data;

     if ( Object == Wizard )
     {
         if      ( Key == PRES_KEY ) Object = Prove;
         else if ( Key == INFO_KEY ) Object = Idiot;
         else if ( Key == CLEAR_KEY )Object = Gone;
         else                        Object = Moron;

     }
     else if ( Object == Prove )
     {
          if      ( Key == ON_KEY   ) Object = Blessed;
          else if ( Key == INFO_KEY ) Object = Idiot;
          else if ( Key == CLEAR_KEY )Object = Gone;
          else                        Object = Moron;
     }
     else if (( Object == Confirm ) && ( Key != DELETE_KEY ))
     {
         Object = Blessed;
     }
     else switch ( Key )
     {
         case TRAY_KEY:    /* Instant Action Key for improved usability */
                           Skip_Power_On_Test = 1;
                           __asm( "  xref boot:PowerUp ");
                           __asm( "  bra.l (PowerUp).l ");
                           break;

         case SEQ_CTRL_KEY:
#if 0
                           Skip_Power_On_Test = 0;
                           PF_Start = 0;
                           __asm( "  xref boot:PowerUp ");
                           __asm( "  bra.l (PowerUp).l ");
#else
                           Object = Credits;
#endif
                           break;


         case STORE_KEY:   InitSetpointTable (Hidden_Pneu_Diag_Tbl );
                           Pneu_Keys_Enabled = FALSE;
                           return;

         case SIGNAL1_KEY: InitSetpointTable( Hidden_Det_Diag_Tbl );
                           Pneu_Keys_Enabled = FALSE;
                           return;

         case PREP_RUN_KEY:  Prepare(Manual);
                           break;

         case STOP_KEY:    StopRun(Abort);
                           break;

         case SEQ_KEY:     Object = Cksum;
                           (void)ReadEeprom( Module, CHECKSUM, &Data );
                           break;

         case OVEN_KEY:    Object = Icap;
                           break;

         case FLOW_KEY:    Object=Stable_Volts;
                           break;

         case RADIX_KEY:  Go = !Go;
                          break;

         case DELETE_KEY: if ( Object == Confirm )
                          {
                            Object = EEprom;
                            number = 0;
                          }
                          else                     Object = Confirm;
                          Range = 0;
                          break;

         case POST_RUN_KEY: Object = ReCalib;
                          break;

         case TEMP_KEY:   if ( Object == Temp ) Object = Temp2;
                          else                  Object = Temp;
                          break;

         case TIME_KEY:   if ( Object == Masks ) Object = Halts;
                          else                   Object = Masks;
                          break;

         case LOAD_KEY:   Object = Load;
                          break;

         case PRES_KEY:   Object = Pres;
                          break;

         case DET_CONTROL_KEY:
                           if      ( Object == Env )        Object = Test_Status;
                           else if ( Object == Test_Status) Object = Test_Regs;
                           else                             Object = Env;
                           break;
         case SIGNAL2_KEY:
                           Object = Environment;
                           break;

         case METHOD_KEY:  if (( Object == Meth_Errors ) && ( meth_check_errors != 0 ))
                           {
                                 Active_Error_Line = ( Active_Error_Line +1 ) % meth_check_errors;
                           }
                           else
                           {
                                 Object = Meth_Errors;
                                 Active_Error_Line = 0;
                           }
                           break;

         case INFO_KEY:    if      ( Object == Pcb_Buffer ) Object = Sent;
                           else if ( Object == Sent )       Object = Recvd;
                           else                             Object = Pcb_Buffer;
                           Which_Line_Active = 0;
                           break;

         case MODE_TYPE_KEY:if     ( Object == Aux3_Ready ) Object = Aux4_Ready;
                           else if ( Object == Aux4_Ready ) Object = Aux5_Ready;
                           else                             Object = Aux3_Ready;
                           break;

         case FRONT_KEY:   if      ( Object == FD_1P_Ready ) Object = FD_2P_Ready;
                           else if ( Object == FD_2P_Ready ) Object = FD_3P_Ready;
                           else if ( Object == FD_3P_Ready ) Object = FD_1F_Ready;
                           else if ( Object == FD_1F_Ready ) Object = FD_2F_Ready;
                           else if ( Object == FD_2F_Ready ) Object = FD_3F_Ready;
                           else                              Object = FD_1P_Ready;
                           break;

         case BACK_KEY:    if      ( Object == BD_1P_Ready ) Object = BD_2P_Ready;
                           else if ( Object == BD_2P_Ready ) Object = BD_3P_Ready;
                           else if ( Object == BD_3P_Ready ) Object = BD_1F_Ready;
                           else if ( Object == BD_1F_Ready ) Object = BD_2F_Ready;
                           else if ( Object == BD_2F_Ready ) Object = BD_3F_Ready;
                           else                              Object = BD_1P_Ready;
                           break;

         case STATUS_KEY:  if ( Object == Sig_Status ) Object = Pneu_Status;
                           else                        Object = Sig_Status;
                           Which_Line_Active = 0;
                           break;
         case F_INLET_KEY: if      ( Object == F_Inlet ) Object = FI_PS;
                           else if ( Object == FI_PS )   Object = FI_FS;
                           else if ( Object == FI_FS )   Object = FI_Flow;
                           else if ( Object == FI_Flow ) Object = FI_FS_Parms;
                           else if ( Object == FI_FS_Parms ) Object = FI_Calib;
                           else                          Object = F_Inlet;
                           Which_Line_Active = 0;
                           break;
         case RUN_LOG_KEY: if      ( Object == FI_P_Ready ) Object = FI_F_Ready;
                           else if ( Object == FI_F_Ready ) Object = BI_P_Ready;
                           else if ( Object == BI_P_Ready ) Object = BI_F_Ready;
                           else                             Object = FI_P_Ready;
                           Which_Line_Active = 0;
                           break;
         case B_INLET_KEY: if      ( Object == B_Inlet ) Object = BI_PS;
                           else if ( Object == BI_PS )   Object = BI_FS;
                           else if ( Object == BI_FS )   Object = BI_Flow;
                           else if ( Object == BI_Flow ) Object = BI_FS_Parms;
                           else if ( Object == BI_FS_Parms ) Object = BI_Calib;
                           else                          Object = B_Inlet;
                           Which_Line_Active = 0;
                           break;

         case F_DET_KEY:   if      ( Object == F_Det   ) Object = FD_G1;
                           else if ( Object == FD_G1   ) Object = FD_G1_V;
                           else if ( Object == FD_G1_V ) Object = FD_G2;
                           else if ( Object == FD_G2   ) Object = FD_G2_V;
                           else if ( Object == FD_G2_V ) Object = FD_G3;
                           else if ( Object == FD_G3   ) Object = FD_G3_V;
                           else if ( Object == FD_G3_V ) Object = FD_Calib;
                           else                          Object = F_Det;
                           Which_Line_Active = 0;
                           break;

         case B_DET_KEY:   if      ( Object == B_Det   ) Object = BD_G1;
                           else if ( Object == BD_G1   ) Object = BD_G1_V;
                           else if ( Object == BD_G1_V ) Object = BD_G2;
                           else if ( Object == BD_G2   ) Object = BD_G2_V;
                           else if ( Object == BD_G2_V ) Object = BD_G3;
                           else if ( Object == BD_G3   ) Object = BD_G3_V;
                           else if ( Object == BD_G3_V ) Object = BD_Calib;
                           else                          Object = B_Det;
                           Which_Line_Active = 0;
                           break;


         case COLUMN1_KEY: if      ( Object == Column1 )  Object = C1_Setpt;
                           else if ( Object == C1_Setpt ) Object = C1_Actual;
                           else                           Object = Column1;
                           Which_Line_Active = 0;
                           break;

         case COLUMN2_KEY: if      ( Object == Column2 )  Object = C2_Setpt;
                           else if ( Object == C2_Setpt ) Object = C2_Actual;
                           else                           Object = Column2;
                           Which_Line_Active = 0;
                           break;

         case AUX_KEY:     if      ( Object == Aux3   ) Object = Aux4;
                           else if ( Object == Aux4   ) Object = Aux5;
                           else if ( Object == Aux5   ) Object = Aux3_V;
                           else if ( Object == Aux3_V ) Object = Aux4_V;
                           else if ( Object == Aux4_V ) Object = Aux5_V;
                           else if ( Object == Aux5_V ) Object = PA_Calib;
                           else                         Object = Aux3;
                           Which_Line_Active = 0;
                           break;

         case CONFIG_KEY:  Object = Pcb;    Which_Line_Active = 0;
                           break;

         case UP_ARROW_KEY: Which_Line_Active = ( --Which_Line_Active ) % 4 ;
                           break;

         case DOWN_ARROW_KEY: Which_Line_Active = ( ++Which_Line_Active ) % 4 ;
                           break;

         case COL_COMP1_KEY: Object = TComp;
                             break;
         case COL_COMP2_KEY: Object = PComp;
                             break;

         case OPTION_KEY: if (( Object == Step ) && ( Super_Wizard ))
                          {
                              Stepping = !Stepping;
                          }
                          Object = Step;
                          break;


         case CLEAR_KEY:  if (( Object == Step ) && (Super_Wizard))
                          {
                              Go = !Go;
                          }
                          Object = Step;
                          break;

         case RAMP_KEY:
                          if      ( Object == Max_Min )     Object = Env_Max_Min;
                          else if ( Object == Env_Max_Min ) Object = RMS_Ctrl;
                          else                              Object = Max_Min;
                          break;

         case TIME_PROG_KEY: if     ( Object == FI_Hdr      ) Object = FI_Therm;
                            else if ( Object == FI_Therm    ) Object = FI_PS_Terms;
                            else if ( Object == FI_PS_Terms ) Object = FI_FS_Parms;
                            else if ( Object == FI_FS_Parms ) Object = FI_SPR;
                            else
                            {
                                 (void)ReadEeprom( FRNT_INLET_MODULE_NUMBER, TEST_STATION_ID, &test_station_id );
                                 (void)ReadEeprom( FRNT_INLET_MODULE_NUMBER, BUILD_DATE,      &build_date      );
                                 (void)ReadEeprom( FRNT_INLET_MODULE_NUMBER, SERIAL_NO_LOW,   &ser_no_low      );
                                 (void)ReadEeprom( FRNT_INLET_MODULE_NUMBER, SERIAL_NO_HIGH,  &ser_no_high     );
                                 Object = FI_Hdr;
                            }
                            break;

         case CLOCK_PROG_KEY: if    ( Object == BI_Hdr      ) Object = BI_Therm;
                            else if ( Object == BI_Therm    ) Object = BI_PS_Terms;
                            else if ( Object == BI_PS_Terms ) Object = BI_FS_Parms;
                            else if ( Object == BI_FS_Parms ) Object = BI_SPR;
                            else
                            {
                                 (void)ReadEeprom( BACK_INLET_MODULE_NUMBER, TEST_STATION_ID, &test_station_id );
                                 (void)ReadEeprom( BACK_INLET_MODULE_NUMBER, BUILD_DATE,      &build_date      );
                                 (void)ReadEeprom( BACK_INLET_MODULE_NUMBER, SERIAL_NO_LOW,   &ser_no_low      );
                                 (void)ReadEeprom( BACK_INLET_MODULE_NUMBER, SERIAL_NO_HIGH,  &ser_no_high     );
                                 Object = BI_Hdr;
                            }
                            break;

         case F_INJECTOR_KEY:if     ( Object == FD_Hdr  )   Object = FD_Therm;
                            else if ( Object == FD_Therm)   Object = FD_PS_1;
                            else if ( Object == FD_PS_1 )   Object = FD_PS_2;
                            else if ( Object == FD_PS_2 )   Object = FD_PS_3;
                            else if ( Object == FD_PS_3 )   Object = FD_Frit_1;
                            else if ( Object == FD_Frit_1 ) Object = FD_Frit_2;
                            else if ( Object == FD_Frit_2 ) Object = FD_Frit_3;
                            else
                            {
                                 (void)ReadEeprom( FRNT_DETECTOR_MODULE_NUMBER, TEST_STATION_ID, &test_station_id );
                                 (void)ReadEeprom( FRNT_DETECTOR_MODULE_NUMBER, BUILD_DATE,      &build_date      );
                                 (void)ReadEeprom( FRNT_DETECTOR_MODULE_NUMBER, SERIAL_NO_LOW,   &ser_no_low      );
                                 (void)ReadEeprom( FRNT_DETECTOR_MODULE_NUMBER, SERIAL_NO_HIGH,  &ser_no_high     );
                                 Object = FD_Hdr;
                            }
                            break;

         case B_INJECTOR_KEY:if     ( Object == BD_Hdr  )   Object = BD_Therm;
                            else if ( Object == BD_Therm)   Object = BD_PS_1;
                            else if ( Object == BD_PS_1 )   Object = BD_PS_2;
                            else if ( Object == BD_PS_2 )   Object = BD_PS_3;
                            else if ( Object == BD_PS_3 )   Object = BD_Frit_1;
                            else if ( Object == BD_Frit_1 ) Object = BD_Frit_2;
                            else if ( Object == BD_Frit_2 ) Object = BD_Frit_3;
                            else
                            {
                                 (void)ReadEeprom( BACK_DETECTOR_MODULE_NUMBER, TEST_STATION_ID, &test_station_id );
                                 (void)ReadEeprom( BACK_DETECTOR_MODULE_NUMBER, BUILD_DATE,      &build_date      );
                                 (void)ReadEeprom( BACK_DETECTOR_MODULE_NUMBER, SERIAL_NO_LOW,   &ser_no_low      );
                                 (void)ReadEeprom( BACK_DETECTOR_MODULE_NUMBER, SERIAL_NO_HIGH,  &ser_no_high     );
                                 Object = BD_Hdr;
                            }
                            break;

         case VALVE_KEY:    if      ( Object == AX_Hdr   ) Object = Aux_Therm;
                            else if ( Object == Aux_Therm) Object = A3_PS;
                            else if ( Object == A3_PS    ) Object = A4_PS;
                            else if ( Object == A4_PS    ) Object = A5_PS;
                            else
                            {
                                 (void)ReadEeprom( PNEU_AUX_MODULE_NUMBER, TEST_STATION_ID, &test_station_id );
                                 (void)ReadEeprom( PNEU_AUX_MODULE_NUMBER, BUILD_DATE,      &build_date      );
                                 (void)ReadEeprom( PNEU_AUX_MODULE_NUMBER, SERIAL_NO_LOW,   &ser_no_low      );
                                 (void)ReadEeprom( PNEU_AUX_MODULE_NUMBER, SERIAL_NO_HIGH,  &ser_no_high     );
                                 Object = AX_Hdr;
                            }
                            break;



         case MINUS_KEY:
         case ZERO_KEY:
         case ONE_KEY:
         case TWO_KEY:
         case THREE_KEY:
         case FOUR_KEY:
         case FIVE_KEY:
         case SIX_KEY:
         case SEVEN_KEY:
         case EIGHT_KEY:
         case NINE_KEY:
         case ON_KEY:
         case OFF_KEY:

              number = 0; /* flexelint fix */
              if ( Key == MINUS_KEY  )
              {
                if (Object != EEprom) break;
                if (( Module == FRNT_INLET_MODULE_NUMBER ) || ( Module == BACK_INLET_MODULE_NUMBER ))
                {
                number = (Type   + LAST_INLET_TYPE ) % (LAST_INLET_TYPE+1) ;
                };
                if (( Module == FRNT_DETECTOR_MODULE_NUMBER ) || ( Module == BACK_DETECTOR_MODULE_NUMBER ))
                {
                number = (Type   + LAST_DET_TYPE ) % (LAST_DET_TYPE+1) ;
                };
              };

              if      ( Key == OFF_KEY    ) number = 0;
              else if ( Key == ON_KEY     ) number = 1;
              else if ( Key == ZERO_KEY   ) number = 0;
              else if ( Key == ONE_KEY    ) number = 1;
              else if ( Key == TWO_KEY    ) number = 2;
              else if ( Key == THREE_KEY  ) number = 3;
              else if ( Key == FOUR_KEY   ) number = 4;
              else if ( Key == FIVE_KEY   ) number = 5;
              else if ( Key == SIX_KEY    ) number = 6;
              else if ( Key == SEVEN_KEY  ) number = 7;
              else if ( Key == EIGHT_KEY  ) number = 8;
              else if ( Key == NINE_KEY   ) number = 9;
              switch ( Object )
              {
                   case Load:
                      Inst_Status.Pneu.Peak_Ctrl_Time = 0;
                      Inst_Status.Pneu.Peak_Disp_Time = 0;
                      break;
                   case Sent:
                   case Recvd:
                   case Max_Min:
                   case Pcb_Buffer: Buffer_Number = number;
                        break;
                   case RMS_Ctrl: if ( number != 0 ) Inst_Status.Pneu.RMS_Interval = number *  5 * 50;
                                  else               Inst_Status.Pneu.RMS_Interval = 100;
                        break;
                   case TComp: if ( !Super_Wizard ) break;
                    switch ( Which_Line_Active )
                    {  case 0: Inst_Status.Pneu.Frnt_Inlet.Tcomp_Tables->Pres_Sensor.Temp_Comp_Enabled = number % 2;
                               Inst_Status.Pneu.Frnt_Inlet.Tcomp_Tables->Flow_Sensor.Temp_Comp_Enabled = number % 2;
                               break;
                       case 1: Inst_Status.Pneu.Back_Inlet.Tcomp_Tables->Pres_Sensor.Temp_Comp_Enabled = number % 2;
                               Inst_Status.Pneu.Back_Inlet.Tcomp_Tables->Flow_Sensor.Temp_Comp_Enabled = number % 2;
                               break;
                       case 2: Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Fuel.Pres_Sensor.Temp_Comp_Enabled = number % 2;
                               Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Util.Pres_Sensor.Temp_Comp_Enabled = number % 2;
                               Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Mug.Pres_Sensor.Temp_Comp_Enabled = number % 2;
                               Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Fuel.Frit.Temp_Comp_Enabled = number % 2;
                               Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Util.Frit.Temp_Comp_Enabled = number % 2;
                               Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Mug.Frit.Temp_Comp_Enabled = number % 2;
                               break;
                       case 3: Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Fuel.Pres_Sensor.Temp_Comp_Enabled = number % 2;
                               Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Util.Pres_Sensor.Temp_Comp_Enabled = number % 2;
                               Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Mug.Pres_Sensor.Temp_Comp_Enabled = number % 2;
                               Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Fuel.Frit.Temp_Comp_Enabled = number % 2;
                               Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Util.Frit.Temp_Comp_Enabled = number % 2;
                               Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Mug.Frit.Temp_Comp_Enabled = number % 2;
                               break;
                    }
                        break;

                   case PComp: if ( ! Super_Wizard ) break;
                        switch ( Which_Line_Active )
                        {  case 0: Inst_Status.Pneu.Column_1.Atm_Pres_Comp_Enabled = number % 2; break;
                           case 1: Inst_Status.Pneu.Column_2.Atm_Pres_Comp_Enabled = number % 2; break;
                        }
                        break;

                   case Cksum:
                          if (( number == 1 ) && ( Which_Line_Active == 3 ))
                          {
                              Programming = 1;
                              Inst_Status.Pneu.Module_Cksums[ Module ] = CalcModuleChecksum( Module );
                              Programming = 0;
                          }
                          else if (( number == 9 ) && ( Which_Line_Active == 3 ) && (Super_Wizard))
                          {
                              (void)WriteEeprom( Module, CHECKSUM, Inst_Status.Pneu.Module_Cksums[ Module ] );
                              (void)ReadEeprom ( Module, CHECKSUM, &Data );
                          }
                          else
                          if (( number <= 4 ) && ( Which_Line_Active == 0 ))
                          {
                               Module = number;
                               (void)ReadEeprom( Module, CHECKSUM, &Data );
                          }
                          break;
                   case Pcb:
                          switch ( Which_Line_Active )
                          {
                             case 0:
                                     Use_Thermal_Setpt = number % 2;
#if 0
                                     LockResource(&Inst_Status.Pneu.Resource_Lock);
                                     ReconfigurePneu();
                                     ReleaseResource(&Inst_Status.Pneu.Resource_Lock);
                                     Inst_Config.Pneu.Dirt_Ball = number % 2;
                                     Dont_Use_Real_Configuration = TRUE;
#endif
                                     break;
                             case 1: Hacksaw = number %2;
                                     Dont_Use_Real_Configuration = TRUE;
                                     break;
                             case 2: Actual_Equals_Setpt = number % 2;
                                     Dont_Use_Real_Configuration = TRUE;
                                     break;
                             case 3: Enable_Solv_Save = number % 2;
                                     break;
                          }
                          break;
                   case Masks:
                                    Inst_Status.Pneu.Restarted_Channel_Mask = 0;
                                    Inst_Status.Pneu.Last_Pcb_Error = 1;
                          break;

                   case Halts: if ( ! Super_Wizard ) break;
                          switch ( Which_Line_Active )
                          {
                              case 0: Inst_Status.Pneu.Halt_On_Error = number != 0;
                                      break;
                              case 1: Inst_Status.Pneu.Halt_On_Shutdown = number != 0;
                                      break;
                              case 2: Inst_Status.Pneu.Halt_On_Cksum_Error = number != 0;
                                      break;
                          }
                          break;
                   case EEprom:
                         switch ( Which_Line_Active )
                         {
                              case 0: Module = number % 5;
                                      break;
                              case 1: if (( Module == FRNT_INLET_MODULE_NUMBER ) ||
                                          ( Module == BACK_INLET_MODULE_NUMBER ))     Type = number % (LAST_INLET_TYPE+1);
                                      else
                                      if (( Module == FRNT_DETECTOR_MODULE_NUMBER ) ||
                                          ( Module == BACK_DETECTOR_MODULE_NUMBER ))  Type = number % (LAST_DET_TYPE+1);
                                      else
                                      if ( Module == PNEU_AUX_MODULE_NUMBER  )   Type = number % 1;
                                      else                                            Type = number;
                                      break;
                              case 2: Range = number % 3;
                                      break;
                              case 3: if ( number == 1 )
                                      {
                                          Object = Erasing;
                                          Programming = 1;
                                      }
                                      else Programming = 0;
                                      if ( Programming == 1 )
                                      {
                                          (void)ReadEeprom( Module, TEST_STATION_ID, &data );
                                          if (( data == 0 ) || ( data == 0xffff ))
                                          {
                                              InitEEPROM( Module, Type, Range );
                                              Programming = 0;
                                          }
                                          else
                                          {
                                              Object = Error_Calibrated;
                                          }
                                      }
                                      break;
                          }
                          break;

                   case ReCalib: if ( ! Super_Wizard ) break;
                         switch ( Which_Line_Active )
                         {
                              case 0: Module = number % 2;
                                      break;
                              case 1: Gas = number % 6;
                                      break;
                              case 3: if ( number == 1 ) Programming = 1;
                                      else Programming = 0;
                                      if ( Programming == 1 )
                                      {
                                          (void) RecalibFlow( Module, (GAS_TYPE)Gas );
                                          Programming = 0;
                                      }
                                      break;
                          }
                          break;

                  case Env:
                      switch ( Which_Line_Active )
                      {
                         case 0:    Inst_Status.Pneu.Environment_Freq = number * 50;
                                    break;
                         case 1:    Inst_Status.Pneu.Auto_Cal_Delay = 50 + number * 10;
                                    break;
                      }
                      break;

                  case FI_FS_Parms:
                  case BI_FS_Parms:
                  case FI_SPR:
                  case BI_SPR:

                             switch ( Object )
                             {
                               case FI_FS_Parms:
                               case FI_SPR:       (void)SetInletGasType ( (GAS_TYPE)number, &Inst_Status.Pneu.Frnt_Inlet  );
                                                  break;
                               case BI_FS_Parms:
                               case BI_SPR:       (void)SetInletGasType ( (GAS_TYPE)number, &Inst_Status.Pneu.Back_Inlet  );
                                                  break;
                             }

                             break;

                  case FD_Frit_1:
                  case FD_Frit_2:
                  case FD_Frit_3:
                  case BD_Frit_1:
                  case BD_Frit_2:
                  case BD_Frit_3:

                             switch ( Object )
                             {
                               case FD_Frit_1: (void)SetDetectorGasType ( &Inst_Status.Pneu.Frnt_Detector,
                                                                          1, (GAS_TYPE)number );
                                                  break;

                               case FD_Frit_2: (void)SetDetectorGasType ( &Inst_Status.Pneu.Frnt_Detector,
                                                                           2, (GAS_TYPE)number );
                                                  break;

                               case FD_Frit_3: (void)SetDetectorGasType ( &Inst_Status.Pneu.Frnt_Detector,
                                                                           3, (GAS_TYPE)number );
                                                  break;

                               case BD_Frit_1: (void)SetDetectorGasType ( &Inst_Status.Pneu.Back_Detector,
                                                                           1,  (GAS_TYPE)number );
                                                  break;

                               case BD_Frit_2: (void)SetDetectorGasType ( &Inst_Status.Pneu.Back_Detector,
                                                                           2,  (GAS_TYPE)number );
                                                  break;

                               case BD_Frit_3: (void)SetDetectorGasType ( &Inst_Status.Pneu.Back_Detector,
                                                                           3,  (GAS_TYPE)number );
                                                  break;

                             }

                             break;

                case FI_Therm:
                case BI_Therm:
                case FD_Therm:
                case BD_Therm:
                case Aux_Therm:
                         switch ( Object )
                         {
                         case FI_Therm: BuildThermistorTable ( Inst_Status.Pneu.Frnt_Inlet.Module_Number,
                                                          &Inst_Status.Pneu.Frnt_Inlet.Tcomp_Tables->Thermistor );
                                        break;
                         case BI_Therm: BuildThermistorTable ( Inst_Status.Pneu.Back_Inlet.Module_Number,
                                                          &Inst_Status.Pneu.Back_Inlet.Tcomp_Tables->Thermistor );
                                        break;
                         case FD_Therm: BuildThermistorTable ( Inst_Status.Pneu.Frnt_Detector.Module_Number,
                                                          &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Thermistor );
                                        break;
                         case BD_Therm: BuildThermistorTable ( Inst_Status.Pneu.Back_Detector.Module_Number,
                                                          &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Thermistor );
                                        break;
                         case Aux_Therm: BuildThermistorTable ( Inst_Status.Pneu.Aux.Module_Number,
                                                          &Inst_Status.Pneu.Aux.Tcomp_Tables->Thermistor );
                                        break;
                         }
                  break;



                  case FD_PS_1:
                  case FD_PS_2:
                  case FD_PS_3:
                  case BD_PS_1:
                  case BD_PS_2:
                  case BD_PS_3:  /* any number will re read ps parms */

                             switch ( Object )
                             {
                               case FD_PS_1: GetPresSensorConstants ( 2, 1,
                                                &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Fuel.Pres_Sensor.Parms );
                                                  break;

                               case FD_PS_2: GetPresSensorConstants ( 2, 2,
                                                &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Util.Pres_Sensor.Parms );
                                                  break;

                               case FD_PS_3: GetPresSensorConstants ( 2, 3,
                                                &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Mug.Pres_Sensor.Parms );
                                                  break;


                               case BD_PS_1: GetPresSensorConstants ( 3, 1,
                                                &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Fuel.Pres_Sensor.Parms );
                                                  break;

                               case BD_PS_2: GetPresSensorConstants ( 3, 2,
                                                &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Util.Pres_Sensor.Parms );
                                                  break;

                               case BD_PS_3: GetPresSensorConstants ( 3, 3,
                                                &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Mug.Pres_Sensor.Parms );
                                                  break;

                             }

                             break;
              }

              /* intentional fall through */

        default: ;

      }


}


/**begin_proto**/

/*#pragma  SECTION UNDO*/

/**end_proto**/

/**begin_proto**/

void PneuFakeDisplay( void )

/**end_proto**/
{

     BIT8  line1[21];
     BIT8  line2[21];
     BIT8  line3[21];
     BIT8  line4[21];
     pDET_GAS_TABLE gas_table;
     pINLET_STATUS  status;
     pCOLUMN_STATUS cstatus;
     pDETECTOR_STATUS  dstatus;
     pAUX_STATUS    astatus;
     pHERE_I_COME   ready;
     U_INT32        scratch[2];
     pTHERMISTOR_PARMS therm;
     pFRIT_PARMS       frit;
     pPRES_SENSOR_PARMS ps;
     pPURGE_REG_STRUCT  spr;
     void               *junk_ptr;
     int  itr;
     int  i;
     int  msg;
     CALIB_STRUCT calib;




     switch ( Object )
     {
         case Moron:

                StrCopy(    (BIT8 *)Pneu_Messages[29],                                                    line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[33],                                                    line4 );

                BuildStringImage( line1, line2, line3, line4 );
                Pneu_Keys_Enabled = FALSE;
                break;
         case Idiot:

                StrCopy(    (BIT8 *)Pneu_Messages[162],                                                   line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[163],                                                   line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line4 );

                BuildStringImage( line1, line2, line3, line4 );
                Pneu_Keys_Enabled = FALSE;
                break;
         case Gone:

                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[21],                                                    line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line4 );

                BuildStringImage( line1, line2, line3, line4 );
                Pneu_Keys_Enabled = FALSE;
                break;
         case Wizard:

                StrCopy(    (BIT8 *)Pneu_Messages[45],                                                    line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line4 );

                BuildStringImage( line1, line2, line3, line4 );
                break;
         case Prove:

                StrCopy(    (BIT8 *)Pneu_Messages[46],                                                    line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line4 );

                BuildStringImage( line1, line2, line3, line4 );
                break;
         case Blessed:

                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[164],                                                   line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[165],                                                   line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[166],                                                   line4 );

                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Confirm:

                StrCopy(    (BIT8 *)Pneu_Messages[125],                                                   line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[126],                                                   line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[127],                                                   line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[128],                                                   line4 );

                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Error_Calibrated:

                StrCopy(    (BIT8 *)Pneu_Messages[245],                                                   line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[246],                                                   line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[247],                                                   line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[248],                                                   line4 );

                BuildStringImage( line1, line2, line3, line4 );
                break;

         case EEprom:

                StrCopy(    (BIT8 *)Pneu_Messages[52],                                                    line1 );
                StrCopyParm((BIT8 *)Modules[ (U_INT8)Module],                                             line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[53],                                                    line2 );
                if (( Module == FRNT_INLET_MODULE_NUMBER ) || ( Module == BACK_INLET_MODULE_NUMBER ))
                    StrCopyParm((BIT8 *)Pneu_Inlet_Types[ (U_INT8)Type%(LAST_INLET_TYPE+1)],              line2 );
                else if (( Module == FRNT_DETECTOR_MODULE_NUMBER ) || ( Module == BACK_DETECTOR_MODULE_NUMBER ))
                    StrCopyParm((BIT8 *)EEprom_Det_Types[ (U_INT8)Type%(LAST_DET_TYPE+1)],                line2 );
                else if ( Module == PNEU_AUX_MODULE_NUMBER )
                    StrCopyParm((BIT8 *)EEprom_Aux_Types[ (U_INT8)Type%2],                                line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[54],                                                    line3 );
                StrCopyParm((BIT8 *)P_Sensor_Types[ (U_INT8)Range],                                       line3 );
                if ( Programming == 1 )
                {
                  StrCopy(    (BIT8 *)Pneu_Messages[56],                                                    line4 );
                  FormatHexHalfWord  ( EEPROM_Write_Address , &line4[5] );
                  FormatHexHalfWord  ( EEPROM_Write_Data , &line4[15] );
                }
                StrCopy(    (BIT8 *)Pneu_Messages[55],                                                    line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;


         case Erasing:

                switch ( Module )
                {
                  case FRNT_INLET_MODULE_NUMBER:      StrCopy((BIT8 *)Pneu_Messages[240],  line1 );
                                                      break;
                  case BACK_INLET_MODULE_NUMBER:      StrCopy((BIT8 *)Pneu_Messages[241],  line1 );
                                                      break;
                  case FRNT_DETECTOR_MODULE_NUMBER:   StrCopy((BIT8 *)Pneu_Messages[242],  line1 );
                                                      break;
                  case BACK_DETECTOR_MODULE_NUMBER:   StrCopy((BIT8 *)Pneu_Messages[243],  line1 );
                                                      break;
                  case PNEU_AUX_MODULE_NUMBER:        StrCopy((BIT8 *)Pneu_Messages[244],  line1 );
                                                      break;
                }
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                    line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                    line3 );

                if ( Programming == 1 )
                {
                  StrCopy(    (BIT8 *)Pneu_Messages[56],                                                    line4 );
                  FormatHexHalfWord  ( EEPROM_Write_Address , &line4[5] );
                  FormatHexHalfWord  ( EEPROM_Write_Data , &line4[15] );
                }
                else if ( Prog_Result == TRUE )
                   StrCopy(    (BIT8 *)Pneu_Messages[51],                                                    line4 );
                else
                   StrCopy(    (BIT8 *)Pneu_Messages[58],                                                    line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;


         case ReCalib:

                StrCopy(    (BIT8 *)Pneu_Messages[149],                                                    line1 );
                StrCopyParm((BIT8 *)Modules[ (U_INT8)Module],                                             line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[150],                                                    line2 );
                StrCopyParm((BIT8 *)Gas_Types[ Gas ], line2 );

                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                     line3 );

                if ( Programming == 1 )
                {
                  StrCopy(    (BIT8 *)Pneu_Messages[56],                                                    line4 );
                  FormatHexHalfWord  ( EEPROM_Write_Address , &line4[5] );
                  FormatHexHalfWord  ( EEPROM_Write_Data , &line4[15] );
                }
                else if ( Prog_Result == TRUE )
                   StrCopy(    (BIT8 *)Pneu_Messages[55],                                                    line4 );
                else
                   StrCopy(    (BIT8 *)Pneu_Messages[58],                                                    line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;



         case Pcb_Buffer:
                StrCopy(    (BIT8 *)Pneu_Messages[40],                                                    line1 );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].filler>>16 , &line1[8] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                     line2 );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[0], &line2[0] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[1], &line2[5] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[2], &line2[10] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[3], &line2[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[41],                                                    line3 );
                FormatHexHalfWord  ( (Pneu_Buffer_Pool[Buffer_Number].filler & 0xffff) , &line3[8] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                     line4 );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[0], &line4[0] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[1], &line4[5] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[2], &line4[10] );

                BuildStringImage( line1, line2, line3, line4 );

              break;

         case Sent:
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                    line1 );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[0], &line1[0] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[1], &line1[5] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[2], &line1[10] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[3], &line1[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                     line2 );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[4], &line2[0] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[5], &line2[5] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[6], &line2[10] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[7], &line2[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                     line3 );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[8], &line3[0] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[9], &line3[5] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[10], &line3[10] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[11], &line3[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                     line4 );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[12], &line4[0] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[13], &line4[5] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[14], &line4[10] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Command[15], &line4[15] );
                BuildStringImage( line1, line2, line3, line4 );
              break;

         case Recvd:
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                    line1 );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[0], &line1[0] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[1], &line1[5] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[2], &line1[10] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[3], &line1[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                     line2 );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[4], &line2[0] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[5], &line2[5] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[6], &line2[10] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[7], &line2[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                     line3 );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[8], &line3[0] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[9], &line3[5] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[10], &line3[10] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[11], &line3[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                     line4 );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[12], &line4[0] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[13], &line4[5] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[14], &line4[10] );
                FormatHexHalfWord  ( Pneu_Buffer_Pool[Buffer_Number].PCB_Response[15], &line4[15] );
                BuildStringImage( line1, line2, line3, line4 );
              break;

         case Max_Min:
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                    line1 );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[ 0],  &line1[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[ 1],  &line1[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[ 2],  &line1[10] );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[ 3],  &line1[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[113],                          line2 );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[ 4],  &line2[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[ 5],  &line2[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[ 6],  &line2[10] );
                StrCopy(    (BIT8 *)Pneu_Messages[114],                                                     line3 );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[ 7],  &line3[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[ 8],  &line3[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[ 9],  &line3[10] );
                StrCopy(    (BIT8 *)Pneu_Messages[115],                                                     line4 );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[10],  &line4[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[11],  &line4[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.MAX_MIN[12],  &line4[10] );
                BuildStringImage( line1, line2, line3, line4 );
              break;

         case Icap:
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                    line1 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[ 0],  &line1[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[ 1],  &line1[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[ 2],  &line1[10] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[ 3],  &line1[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[133],                          line2 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[ 4],  &line2[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[ 5],  &line2[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[ 6],  &line2[10] );
                StrCopy(    (BIT8 *)Pneu_Messages[134],                                                     line3 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[ 7],  &line3[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[ 8],  &line3[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[ 9],  &line3[10] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                     line4 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[10],  &line4[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[11],  &line4[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Iscc[12],  &line4[10] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Last_Icap_Ctr,  &line4[15] );
                BuildStringImage( line1, line2, line3, line4 );
              break;

         case Env_Max_Min:
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                    line1 );
                FormatHexHalfWord  ( Inst_Status.Pneu.ENV_MAX_MIN[ 0],  &line1[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.ENV_MAX_MIN[ 1],  &line1[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.ENV_MAX_MIN[ 2],  &line1[10] );
                FormatHexHalfWord  ( Inst_Status.Pneu.ENV_MAX_MIN[ 3],  &line1[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[130],                                                  line2 );
                FormatHexHalfWord  ( Inst_Status.Pneu.ENV_MAX_MIN[ 4],  &line2[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.ENV_MAX_MIN[ 5],  &line2[5] );
                StrCopy(    (BIT8 *)Pneu_Messages[131],                                                  line3 );
                FormatHexHalfWord  ( Inst_Status.Pneu.ENV_MAX_MIN[ 6],  &line3[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.ENV_MAX_MIN[ 7],  &line3[5] );
                StrCopy(    (BIT8 *)Pneu_Messages[132],                                                  line4 );
                FormatHexHalfWord  ( Inst_Status.Pneu.ENV_MAX_MIN[ 8],  &line4[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.ENV_MAX_MIN[ 9],  &line4[5] );
                BuildStringImage( line1, line2, line3, line4 );
              break;

         case Stable_Volts:
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                    line1 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[ 0],  &line1[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[ 1],  &line1[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[ 2],  &line1[10] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[ 3],  &line1[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                          line2 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[ 4],  &line2[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[ 5],  &line2[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[ 6],  &line2[10] );
                StrCopy(    (BIT8 *)Pneu_Messages[116],                                                     line3 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[ 7],  &line3[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[ 8],  &line3[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[ 9],  &line3[10] );
                StrCopy(    (BIT8 *)Pneu_Messages[117],                                                     line4 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[10],  &line4[0] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[11],  &line4[5] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Stable_Volts[12],  &line4[10] );
                BuildStringImage( line1, line2, line3, line4 );
              break;

         case RMS_Ctrl:
                StrCopy(    (BIT8 *)Pneu_Messages[  0],                        line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[123],                        line2 );
                FakeRealFormat( Inst_Status.Pneu.RMS_Interval / 50, 1,   &line2[ 13 ] );

                StrCopy(    (BIT8 *)Pneu_Messages[122],                        line3 );
                FormatHexHalfWord  ( Inst_Status.Pneu.RMS_Interval - Inst_Status.Pneu.RMS_Counts,  &line3[15] );

                StrCopy(    (BIT8 *)Pneu_Messages[0],                          line4 );
                BuildStringImage( line1, line2, line3, line4 );
              break;

         case Step:
                StrCopy(    (BIT8 *)Pneu_Messages[42],                                                    line1 );
                StrCopyParm((BIT8 *)On_Off_Labels[ (U_INT8)(Stepping==1)],                                line1 );
                if (Pcb_Cmd_Sent)
                {
                   StrCopy( (BIT8 *)Pneu_Messages[ 0], line2 );
                   StrCopy( (BIT8 *)Pneu_Messages[44], line3 );
                   StrCopyParm((BIT8 *)My_Digits[Active_Buffer_Number] , line3 );
                }
                else
                {
                   StrCopy( (BIT8 *)Pneu_Messages[43], line2 );
                   StrCopyParm((BIT8 *)My_Digits[Active_Buffer_Number] , line2 );
                   StrCopy( (BIT8 *)Pneu_Messages[ 0], line3 );
                }
                StrCopy(    (BIT8 *)Pneu_Messages[48],                                                    line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Sig_Status:
                StrCopy(    (BIT8 *)Pneu_Messages[103],                                                    line1 );
                FormatHex  ( Soft_Error_Counts.Sig_Retry, &line1[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[104],                                                    line2 );
                FormatHex  ( Soft_Error_Counts.Sig_Lost_Data_In, &line2[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[105],                                                    line3 );
                FormatHex  ( Soft_Error_Counts.Sig_Lost_Data_Out, &line3[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[129],                                                    line4 );
                FormatHexHalfWord  ( Det_DSP_Status,  &line4[15] );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Pneu_Status:
                StrCopy(    (BIT8 *)Pneu_Messages[106],                                                    line1 );
                FormatHex  ( Soft_Error_Counts.Pneu_Read_Cksum, &line1[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[107],                                                    line2 );
                FormatHex  ( Soft_Error_Counts.Pneu_Write_Cksum, &line2[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[108],                                                    line3 );
                FormatHex  ( Soft_Error_Counts.Pneu_Error, &line3[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                    line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case F_Inlet:
                StrCopy(    (BIT8 *)Pneu_Messages[1],                                                    line1 );
                if ( Inst_Config.Pneu.Frnt_Inlet.Functional )
                   StrCopyParm((BIT8 *)Pneu_Inlet_Types[ (U_INT8)Inst_Config.Pneu.Frnt_Inlet.Type],      line1 );
                else
                   StrCopyParm((BIT8 *)Broken_Str[0],      line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[2],                                                    line2 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Frnt_Inlet.Tcomp_Tables->Pres_Sensor.Parms.Range,  &line2[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[3],                                                    line3 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Frnt_Inlet.Dcm2_Per_IU,  &line3[10] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Frnt_Inlet.IU_Scaling,   &line3[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[22],                                                   line4 );
                FakeIntFormat( Frnt_Inlet_Tcomp_Tables.Flow_Sensor.Parms.Max_Flow /
                               Inst_Status.Pneu.Frnt_Inlet.IU_Scaling, &line4[5] );
                StrCopyParm((BIT8 *)Gas_Types[ (U_INT8)Inst_Config.Pneu.Frnt_Inlet.Gas_Type], line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case B_Inlet:
                StrCopy(    (BIT8 *)Pneu_Messages[4],                                                    line1 );
                if ( Inst_Config.Pneu.Back_Inlet.Functional )
                   StrCopyParm((BIT8 *)Pneu_Inlet_Types[ (U_INT8)Inst_Config.Pneu.Back_Inlet.Type],         line1 );
                else
                   StrCopyParm((BIT8 *)Broken_Str[0],      line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[2],                                                    line2 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Back_Inlet.Tcomp_Tables->Pres_Sensor.Parms.Range,  &line2[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[3],                                                    line3 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Back_Inlet.Dcm2_Per_IU,  &line3[10] );
                FormatHexHalfWord  ( Inst_Status.Pneu.Back_Inlet.IU_Scaling,   &line3[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[22],                                                    line4 );
                FakeIntFormat( Back_Inlet_Tcomp_Tables.Flow_Sensor.Parms.Max_Flow /
                               Inst_Status.Pneu.Back_Inlet.IU_Scaling, &line4[5] );
                StrCopyParm((BIT8 *)Gas_Types[ (U_INT8)Inst_Config.Pneu.Back_Inlet.Gas_Type], line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Column1:
                StrCopy(    (BIT8 *)Pneu_Messages[5],                                                    line1 );
                FormatHex  ( Inst_Status.Pneu.Column_1.C1, &line1[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[6],                                                    line2 );
                FormatHex  ( Inst_Status.Pneu.Column_1.C2, &line2[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[7],                                                    line3 );
                FormatHex  ( Inst_Status.Pneu.Column_1.C3, &line3[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[8],                                                    line4 );
                FormatHex  ( Inst_Status.Pneu.Column_1.Vel_IU_Scaling, &line4[3] );
                FormatHex  ( Inst_Status.Pneu.Column_1.IU_Scaling, &line4[11] );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Column2:
                StrCopy(    (BIT8 *)Pneu_Messages[9],                                                    line1 );
                FormatHex  ( Inst_Status.Pneu.Column_2.C1, &line1[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[10],                                                   line2 );
                FormatHex  ( Inst_Status.Pneu.Column_2.C2, &line2[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[11],                                                   line3 );
                FormatHex  ( Inst_Status.Pneu.Column_2.C3, &line3[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[12],                                                   line4 );
                FormatHex  ( Inst_Status.Pneu.Column_2.Vel_IU_Scaling, &line4[3] );
                FormatHex  ( Inst_Status.Pneu.Column_2.IU_Scaling, &line4[11] );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case F_Det:
                StrCopy(    (BIT8 *)Pneu_Messages[13],                                                   line1 );
                if ( Inst_Config.Pneu.Frnt_Detector.Functional )
                  switch ( Inst_Config.Pneu.Frnt_Detector.Type )
                  {
                     case EPC_FID  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 0], line1 ); break;
                     case EPC_TCD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 1], line1 ); break;
                     case EPC_NPD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 2], line1 ); break;
                     case EPC_ECD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 3], line1 ); break;
                     case EPC_FPD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 4], line1 ); break;
                     case MAN_FID  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 5], line1 ); break;
                     case MAN_TCD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 6], line1 ); break;
                     case MAN_NPD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 7], line1 ); break;
                     case MAN_ECD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 8], line1 ); break;
                     case MAN_FPD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 9], line1 ); break;
                     case EPC_uECD : StrCopyParm((BIT8 *)EEprom_Det_Types[10], line1 ); break;
                     case EPC_uECD2: StrCopyParm((BIT8 *)EEprom_Det_Types[11], line1 ); break;
                     case EPC_LDID : StrCopyParm((BIT8 *)EEprom_Det_Types[12], line1 ); break;
                  }
                else
                   StrCopyParm((BIT8 *)Broken_Str[0],      line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                    line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                    line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                    line4 );

                FormatHexHalfWord( Inst_Status.Pneu.Frnt_Detector.Gas_1.P_Sensor_Range, &line2[ 0] );
                FormatHexHalfWord( Inst_Status.Pneu.Frnt_Detector.Gas_1.Dcm2_Per_IU,    &line2[ 5] );
                FormatHex        ( Inst_Status.Pneu.Frnt_Detector.Gas_1.IU_Scaling,     &line2[ 7] );
                FakeIntFormat    ( Frnt_Det_Tcomp_Tables.Fuel.Frit.Parms.Max_Flow /
                                   Inst_Status.Pneu.Frnt_Detector.Gas_1.IU_Scaling ,    &line2[13] );

                FormatHexHalfWord( Inst_Status.Pneu.Frnt_Detector.Gas_2.P_Sensor_Range, &line3[ 0] );
                FormatHexHalfWord( Inst_Status.Pneu.Frnt_Detector.Gas_2.Dcm2_Per_IU,    &line3[ 5] );
                FormatHex        ( Inst_Status.Pneu.Frnt_Detector.Gas_2.IU_Scaling,     &line3[ 7] );
                FakeIntFormat    ( Frnt_Det_Tcomp_Tables.Util.Frit.Parms.Max_Flow /
                                   Inst_Status.Pneu.Frnt_Detector.Gas_2.IU_Scaling ,    &line3[13] );

                FormatHexHalfWord( Inst_Status.Pneu.Frnt_Detector.Gas_3.P_Sensor_Range, &line4[ 0] );
                FormatHexHalfWord( Inst_Status.Pneu.Frnt_Detector.Gas_3.Dcm2_Per_IU,    &line4[ 5] );
                FormatHex        ( Inst_Status.Pneu.Frnt_Detector.Gas_3.IU_Scaling,     &line4[ 7] );
                FakeIntFormat    ( Frnt_Det_Tcomp_Tables.Mug.Frit.Parms.Max_Flow /
                                   Inst_Status.Pneu.Frnt_Detector.Gas_3.IU_Scaling ,    &line4[13] );

                BuildStringImage ( line1,line2,line3,line4);
                break;

         case B_Det:
                StrCopy(    (BIT8 *)Pneu_Messages[14],                                                   line1 );
                if ( Inst_Config.Pneu.Back_Detector.Functional )
                  switch ( Inst_Config.Pneu.Back_Detector.Type )
                  {
                     case EPC_FID  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 0], line1 ); break;
                     case EPC_TCD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 1], line1 ); break;
                     case EPC_NPD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 2], line1 ); break;
                     case EPC_ECD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 3], line1 ); break;
                     case EPC_FPD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 4], line1 ); break;
                     case MAN_FID  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 5], line1 ); break;
                     case MAN_TCD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 6], line1 ); break;
                     case MAN_NPD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 7], line1 ); break;
                     case MAN_ECD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 8], line1 ); break;
                     case MAN_FPD  : StrCopyParm((BIT8 *)EEprom_Det_Types[ 9], line1 ); break;
                     case EPC_uECD : StrCopyParm((BIT8 *)EEprom_Det_Types[10], line1 ); break;
                     case EPC_uECD2: StrCopyParm((BIT8 *)EEprom_Det_Types[11], line1 ); break;
                     case EPC_LDID : StrCopyParm((BIT8 *)EEprom_Det_Types[12], line1 ); break;
                  }
                else
                   StrCopyParm((BIT8 *)Broken_Str[0],      line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                    line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                    line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                    line4 );

                FormatHexHalfWord( Inst_Status.Pneu.Back_Detector.Gas_1.P_Sensor_Range, &line2[ 0] );
                FormatHexHalfWord( Inst_Status.Pneu.Back_Detector.Gas_1.Dcm2_Per_IU,    &line2[ 5] );
                FormatHex        ( Inst_Status.Pneu.Back_Detector.Gas_1.IU_Scaling,     &line2[ 7] );
                FakeIntFormat    ( Back_Det_Tcomp_Tables.Fuel.Frit.Parms.Max_Flow /
                                   Inst_Status.Pneu.Back_Detector.Gas_1.IU_Scaling ,    &line2[13] );

                FormatHexHalfWord( Inst_Status.Pneu.Back_Detector.Gas_2.P_Sensor_Range, &line3[ 0] );
                FormatHexHalfWord( Inst_Status.Pneu.Back_Detector.Gas_2.Dcm2_Per_IU,    &line3[ 5] );
                FormatHex        ( Inst_Status.Pneu.Back_Detector.Gas_2.IU_Scaling,     &line3[ 7] );
                FakeIntFormat    ( Back_Det_Tcomp_Tables.Util.Frit.Parms.Max_Flow /
                                   Inst_Status.Pneu.Back_Detector.Gas_2.IU_Scaling ,    &line3[13] );

                FormatHexHalfWord( Inst_Status.Pneu.Back_Detector.Gas_3.P_Sensor_Range, &line4[ 0] );
                FormatHexHalfWord( Inst_Status.Pneu.Back_Detector.Gas_3.Dcm2_Per_IU,    &line4[ 5] );
                FormatHex        ( Inst_Status.Pneu.Back_Detector.Gas_3.IU_Scaling,     &line4[ 7] );
                FakeIntFormat    ( Back_Det_Tcomp_Tables.Mug.Frit.Parms.Max_Flow /
                                   Inst_Status.Pneu.Back_Detector.Gas_3.IU_Scaling ,    &line4[13] );

                BuildStringImage ( line1,line2,line3,line4);
                break;


         case TComp:
                StrCopy(    (BIT8 *)Pneu_Messages[94],                                                   line1 );
                StrCopyParm(
          (BIT8 *)On_Off_Labels[ Inst_Status.Pneu.Frnt_Inlet.Tcomp_Tables->Pres_Sensor.Temp_Comp_Enabled ],      line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[95],                                                   line2 );
                StrCopyParm(
          (BIT8 *)On_Off_Labels[ Inst_Status.Pneu.Back_Inlet.Tcomp_Tables->Pres_Sensor.Temp_Comp_Enabled ],      line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[96],                                                   line3 );
                StrCopyParm(
         (BIT8 *)On_Off_Labels[ Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Fuel.Pres_Sensor.Temp_Comp_Enabled ],   line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[97],                                                   line4 );
                StrCopyParm(
         (BIT8 *)On_Off_Labels[ Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Fuel.Pres_Sensor.Temp_Comp_Enabled ],   line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case PComp:
                StrCopy(    (BIT8 *)Pneu_Messages[92],                                                   line1 );
                StrCopyParm((BIT8 *)On_Off_Labels[ Inst_Status.Pneu.Column_1.Atm_Pres_Comp_Enabled ],      line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[93],                                                   line2 );
                StrCopyParm((BIT8 *)On_Off_Labels[ Inst_Status.Pneu.Column_2.Atm_Pres_Comp_Enabled ],      line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                   line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[ 0],                                                   line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Env:
                StrCopy(    (BIT8 *)Pneu_Messages[83],                                                   line1 );
                FakeIntFormat( (INT32)Inst_Status.Pneu.Environment_Freq, &line1[12] );
                StrCopy(    (BIT8 *)Pneu_Messages[249],                                                  line2 );
                FakeIntFormat( Inst_Status.Pneu.Auto_Cal_Delay, &line2[12] );

                StrCopy(    (BIT8 *)Pneu_Messages[277],                                                  line3 );
                FormatHex  ( Last_Ioff_Address, &line3[11] );
                StrCopy(    (BIT8 *)Pneu_Messages[278],                                                  line4 );
                FakeIntFormat ( Last_Interrupt_Level, &line4[12] );

                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Aux3:
                StrCopy(    (BIT8 *)Pneu_Messages[18],                                                   line1 );
                if ( !Inst_Config.Pneu.Aux_3.Functional ) StrCopyParm((BIT8 *)Broken_Str[0],      line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[2],                                                    line2 );
                FormatHexHalfWord( Inst_Status.Pneu.Aux.Aux_3.P_Sensor_Range, &line2[15] );
                FormatHexHalfWord( Inst_Status.Pneu.Aux.Aux_3.Dcm2_Per_IU,    &line2[10] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                    line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[22],                                                   line4 );
                StrCopyParm((BIT8 *)Gas_Types[ (U_INT8)Inst_Config.Pneu.Aux_3.Gas_Type], line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Aux4:
                StrCopy(    (BIT8 *)Pneu_Messages[19],                                                   line1 );
                if ( !Inst_Config.Pneu.Aux_4.Functional ) StrCopyParm((BIT8 *)Broken_Str[0],      line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[2],                                                    line2 );
                FormatHexHalfWord( Inst_Status.Pneu.Aux.Aux_4.P_Sensor_Range, &line2[15] );
                FormatHexHalfWord( Inst_Status.Pneu.Aux.Aux_4.Dcm2_Per_IU,    &line2[10] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                    line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[22],                                                   line4 );
                StrCopyParm((BIT8 *)Gas_Types[ (U_INT8)Inst_Config.Pneu.Aux_4.Gas_Type], line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Aux5:
                StrCopy(    (BIT8 *)Pneu_Messages[20],                                                   line1 );
                if ( !Inst_Config.Pneu.Aux_5.Functional ) StrCopyParm((BIT8 *)Broken_Str[0],      line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[2],                                                    line2 );
                FormatHexHalfWord( Inst_Status.Pneu.Aux.Aux_5.P_Sensor_Range, &line2[15] );
                FormatHexHalfWord( Inst_Status.Pneu.Aux.Aux_5.Dcm2_Per_IU,    &line2[10] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                     line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[22],                                                    line4 );
                StrCopyParm((BIT8 *)Gas_Types[ (U_INT8)Inst_Config.Pneu.Aux_5.Gas_Type], line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Pcb:
                if ( Use_Thermal_Setpt )
                   StrCopy( (BIT8 *)Pneu_Messages[147],                                                  line1 );
                else
                   StrCopy( (BIT8 *)Pneu_Messages[148],                                                  line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[38+Hacksaw],                                           line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[57],                                                   line3 );
                StrCopyParm((BIT8 *)On_Off_Labels[Actual_Equals_Setpt ],                                 line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[121],                                                  line4 );
                StrCopyParm((BIT8 *)On_Off_Labels[Enable_Solv_Save ],                                    line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Halts:
                StrCopy(    (BIT8 *)Pneu_Messages[155],              line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[156],              line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[157],              line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                line4 );
                StrCopyParm((BIT8 *)On_Off_Labels[Inst_Status.Pneu.Halt_On_Error], line1 );
                StrCopyParm((BIT8 *)On_Off_Labels[Inst_Status.Pneu.Halt_On_Shutdown], line2 );
                StrCopyParm((BIT8 *)On_Off_Labels[Inst_Status.Pneu.Halt_On_Cksum_Error], line3 );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Masks:
                StrCopy(    (BIT8 *)Pneu_Messages[60],                                                   line1 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Channels_Reported_Shutdown,  &line1[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[59],                                                   line2 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Restarted_Channel_Mask,  &line2[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[61],                                                   line3 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Poweron_Selftest_Return,  &line3[15] );
                StrCopy(    (BIT8 *)Pneu_Messages[62],                                                   line4 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Last_Pcb_Error,           &line4[15] );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Temp:
                StrCopy(    (BIT8 *)Pneu_Messages[78],                                                   line1 );
                FakeTempFormat( Inst_Status.Pneu.Frnt_Inlet.Tcomp_Tables->Thermistor.Module_Temperature,  &line1[12] );
                FormatHexHalfWord ( Inst_Status.Pneu.Environment.Frnt_Inlet_Temp,                        &line1[7] );
                StrCopy(    (BIT8 *)Pneu_Messages[79],                                                   line2 );
                FakeTempFormat( Inst_Status.Pneu.Back_Inlet.Tcomp_Tables->Thermistor.Module_Temperature,  &line2[12] );
                FormatHexHalfWord ( Inst_Status.Pneu.Environment.Back_Inlet_Temp,                       &line2[7] );
                StrCopy(    (BIT8 *)Pneu_Messages[80],                                                   line3 );
                FakeTempFormat( Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Thermistor.Module_Temperature, &line3[12]);
                FormatHexHalfWord ( Inst_Status.Pneu.Environment.Frnt_Det_Temp,                            &line3[7] );
                StrCopy(    (BIT8 *)Pneu_Messages[81],                                                   line4 );
                FakeTempFormat( Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Thermistor.Module_Temperature, &line4[12]);
                FormatHexHalfWord ( Inst_Status.Pneu.Environment.Back_Det_Temp,                            &line4[7] );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Temp2:
                StrCopy(    (BIT8 *)Pneu_Messages[23],                                                   line1 );
                FakeTempFormat  ( Inst_Status.Pneu.Aux.Tcomp_Tables->Thermistor.Module_Temperature,  &line1[12] );
                FormatHexHalfWord ( Inst_Status.Pneu.Environment.Aux_Temp,                           &line1[7] );
                StrCopy(    (BIT8 *)Pneu_Messages[0], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[0], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[0], line4 );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Load:
                StrCopy(    (BIT8 *)Pneu_Messages[63],                                                   line1 );
                FakeRealFormat  ( Inst_Status.Pneu.Avg_Ctrl_Time, 1000,  &line1[ 9] );
                StrCopy(    (BIT8 *)Pneu_Messages[64],                                                   line2 );
                FakeRealFormat  ( Inst_Status.Pneu.Peak_Ctrl_Time, 1000,  &line2[ 9] );
                StrCopy(    (BIT8 *)Pneu_Messages[65],                                                   line3 );
                FakeRealFormat  ( Inst_Status.Pneu.Avg_Disp_Time, 1000,  &line3[ 9] );
                StrCopy(    (BIT8 *)Pneu_Messages[66],                                                   line4 );
                FakeRealFormat  ( Inst_Status.Pneu.Peak_Disp_Time, 1000,  &line4[ 9] );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Environment:
                StrCopy(    (BIT8 *)Pneu_Messages[109],                                                   line1 );
                FormatHexHalfWord ( Inst_Status.Pneu.Environment.Ten_Volts,             &line1[ 7] );
                FakeRealFormat  ( (INT32)Inst_Status.Pneu.Environment.Ten_Volt_Offset*10000/13107, 10000,  &line1[12] );
                StrCopy(    (BIT8 *)Pneu_Messages[110],                                                   line2 );
                FormatHexHalfWord ( Inst_Status.Pneu.Environment.ADC_Offset_Volts,      &line2[ 7] );
                FakeRealFormat  ( (INT32)Inst_Status.Pneu.Environment.ADC_Offset*10000/13107,     10000,  &line2[12] );
                StrCopy(    (BIT8 *)Pneu_Messages[111],                                                   line3 );
                FormatHexHalfWord ( Inst_Status.Pneu.Environment.Frnt_Inlet_Gas,        &line3[ 7] );
                FakeRealFormat  ( (INT32)Inst_Status.Pneu.Environment.Frnt_Inlet_Gas*10000/13107, 10000,  &line3[12] );
                StrCopy(    (BIT8 *)Pneu_Messages[112],                                                   line4 );
                FormatHexHalfWord ( Inst_Status.Pneu.Environment.Back_Inlet_Gas,        &line4[ 7] );
                FakeRealFormat  ( (INT32)Inst_Status.Pneu.Environment.Back_Inlet_Gas*10000/13107, 10000,  &line4[12] );
                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Cksum:
                StrCopy(    (BIT8 *)Pneu_Messages[158], line1 );
                StrCopyParm((BIT8 *)Modules[ (U_INT8)Module],                                             line1 );

                StrCopy(    (BIT8 *)Pneu_Messages[159], line2 );
                FormatHexHalfWord  ( Inst_Status.Pneu.Module_Cksums[ Module ] ,  &line2[15] );

                StrCopy(    (BIT8 *)Pneu_Messages[160], line3 );
                FormatHexHalfWord  ( Data,  &line3[15] );

                if ( Programming )
                {
                    StrCopy(    (BIT8 *)Pneu_Messages[56],                                                    line4 );
                    FormatHexHalfWord  ( EEPROM_Write_Address , &line4[5] );
                    FormatHexHalfWord  ( EEPROM_Write_Data , &line4[15] );
                }
                else
                {
                    StrCopy(    (BIT8 *)Pneu_Messages[161], line4 );
                }

                BuildStringImage( line1, line2, line3, line4 );
                break;
         case Pres:
                StrCopy(    (BIT8 *)Pneu_Messages[67],                                                   line1 );
                FakeRealFormat(QuadWordMultiplyDivide( Atmospheric_Pressure.Dcm2_80,800000, 6894757), 100, &line1[7] );
                StrCopy(    (BIT8 *)Pneu_Messages[68],                                                  line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                   line3 );
                FakeRealFormat(QuadWordMultiplyDivide( Atmospheric_Pressure.Dcm2_80,800000, 3386015), 100, &line2[7] );
                  if      (Atmospheric_Pressure.Dcm2_80 < 0x2f21 ) StrCopyParm((BIT8 *)Pres_Names[0 ], line3 );
                  else if (Atmospheric_Pressure.Dcm2_80 < 0x2ff9 ) StrCopyParm((BIT8 *)Pres_Names[1 ], line3 );
                  else if (Atmospheric_Pressure.Dcm2_80 < 0x31a8 ) StrCopyParm((BIT8 *)Pres_Names[2 ], line3 );
                  else if (Atmospheric_Pressure.Dcm2_80 < 0x327f ) StrCopyParm((BIT8 *)Pres_Names[3 ], line3 );
                  else                                             StrCopyParm((BIT8 *)Pres_Names[4 ], line3 );
                FakeRealFormat(QuadWordMultiplyDivide( Inst_Status.Pneu.Environment.Atm_Pres, 1000, 13107 ),
                                                       1000, &line2[0] );
                StrCopy(    (BIT8 *)Pneu_Messages[0],                                                   line4 );
                FormatHexHalfWord  ( Atmospheric_Pressure.Dcm2_80,   &line4[0] );
                FormatHexHalfWord  ( Atmospheric_Pressure.Dcm2_160,  &line4[5] );
                FormatHexHalfWord  ( Atmospheric_Pressure.Dcm2_320,  &line4[10] );
/*              FormatHexHalfWord  ( BDet_Switches,                  &line4[15] );         */
                BuildStringImage( line1, line2, line3, line4 );
                break;


         case Meth_Errors:

                if ( meth_check_errors == 0 )
                {
                   StrCopy(    (BIT8 *)Pneu_Messages[47], line1 );
                   StrCopy(    (BIT8 *)Pneu_Messages[ 0], line2 );
                   StrCopy(    (BIT8 *)Pneu_Messages[ 0], line3 );
                   StrCopy(    (BIT8 *)Pneu_Messages[ 0], line4 );
                }
                else
                {
                   StrCopy(    (BIT8 *)Pneu_Messages[199], line1 );

                   switch ( meth_error_list [ Active_Error_Line ].item )
                   {
                   case DIRTBALL                :  StrCopy( (BIT8 *)"Dirtball            \015", line2 ); break;
                   case FRNT_INLET_TYPE         :  StrCopy( (BIT8 *)"Finlet type         \015", line2 ); break;
                   case FRNT_INLET_EPC          :  StrCopy( (BIT8 *)"Finlet epc          \015", line2 ); break;
                   case FRNT_INLET_RANGE        :  StrCopy( (BIT8 *)"Finlet range        \015", line2 ); break;
                   case FRNT_INLET_PRES_EQUIB   :  StrCopy( (BIT8 *)"Finlet pres equib   \015", line2 ); break;
                   case FRNT_INLET_FLOW_EQUIB   :  StrCopy( (BIT8 *)"Finlet flow equib   \015", line2 ); break;
                   case FRNT_INLET_GAS_TYPE     :  StrCopy( (BIT8 *)"Finlet gas type     \015", line2 ); break;
                   case BACK_INLET_TYPE         :  StrCopy( (BIT8 *)"Binlet type         \015", line2 ); break;
                   case BACK_INLET_EPC          :  StrCopy( (BIT8 *)"Binlet epc          \015", line2 ); break;
                   case BACK_INLET_RANGE        :  StrCopy( (BIT8 *)"Binlet range        \015", line2 ); break;
                   case BACK_INLET_PRES_EQUIB   :  StrCopy( (BIT8 *)"Binlet pres equib   \015", line2 ); break;
                   case BACK_INLET_FLOW_EQUIB   :  StrCopy( (BIT8 *)"Binlet flow equib   \015", line2 ); break;
                   case BACK_INLET_GAS_TYPE     :  StrCopy( (BIT8 *)"Binlet gas type     \015", line2 ); break;
                   case FRNT_DET_EPC            :  StrCopy( (BIT8 *)"Fdet epc            \015", line2 ); break;
                   case FRNT_DET_FUEL_RANGE     :  StrCopy( (BIT8 *)"Fdet fuel range     \015", line2 ); break;
                   case FRNT_DET_UTIL_RANGE     :  StrCopy( (BIT8 *)"Fdet util range     \015", line2 ); break;
                   case FRNT_DET_MUG_RANGE      :  StrCopy( (BIT8 *)"Fdet mug range      \015", line2 ); break;
                   case FRNT_DET_UTIL_GAS_TYPE  :  StrCopy( (BIT8 *)"Fdet util gas type  \015", line2 ); break;
                   case FRNT_DET_MUG_GAS_TYPE   :  StrCopy( (BIT8 *)"Fdet mug gas type   \015", line2 ); break;
                   case BACK_DET_EPC            :  StrCopy( (BIT8 *)"Bdet epc            \015", line2 ); break;
                   case BACK_DET_FUEL_RANGE     :  StrCopy( (BIT8 *)"Bdet fuel range     \015", line2 ); break;
                   case BACK_DET_UTIL_RANGE     :  StrCopy( (BIT8 *)"Bdet util range     \015", line2 ); break;
                   case BACK_DET_MUG_RANGE      :  StrCopy( (BIT8 *)"Bdet mug range      \015", line2 ); break;
                   case BACK_DET_UTIL_GAS_TYPE  :  StrCopy( (BIT8 *)"Bdet util gas type  \015", line2 ); break;
                   case BACK_DET_MUG_GAS_TYPE   :  StrCopy( (BIT8 *)"Bdet mug gas type   \015", line2 ); break;
                   case AUX_3_TYPE              :  StrCopy( (BIT8 *)"Aux 3 type          \015", line2 ); break;
                   case AUX_3_RANGE             :  StrCopy( (BIT8 *)"Aux 3 range         \015", line2 ); break;
                   case AUX_3_PRES_EQUIB        :  StrCopy( (BIT8 *)"Aux 3 pres equib    \015", line2 ); break;
                   case AUX_3_GAS_TYPE          :  StrCopy( (BIT8 *)"Aux 3 gas type      \015", line2 ); break;
                   case AUX_4_TYPE              :  StrCopy( (BIT8 *)"Aux 4 type          \015", line2 ); break;
                   case AUX_4_RANGE             :  StrCopy( (BIT8 *)"Aux 4 range         \015", line2 ); break;
                   case AUX_4_PRES_EQUIB        :  StrCopy( (BIT8 *)"Aux 4 pres equib    \015", line2 ); break;
                   case AUX_4_GAS_TYPE          :  StrCopy( (BIT8 *)"Aux 4 gas type      \015", line2 ); break;
                   case AUX_5_TYPE              :  StrCopy( (BIT8 *)"Aux 5 type          \015", line2 ); break;
                   case AUX_5_RANGE             :  StrCopy( (BIT8 *)"Aux 5 range         \015", line2 ); break;
                   case AUX_5_PRES_EQUIB        :  StrCopy( (BIT8 *)"Aux 5 pres equib    \015", line2 ); break;
                   case AUX_5_GAS_TYPE          :  StrCopy( (BIT8 *)"Aux 5 gas type      \015", line2 ); break;
                   case COLUMN1_LENGTH          :  StrCopy( (BIT8 *)"C1 length           \015", line2 ); break;
                   case COLUMN1_DIAM            :  StrCopy( (BIT8 *)"C1 diam             \015", line2 ); break;
                   case COLUMN1_FILM_THICK      :  StrCopy( (BIT8 *)"C1 film thick       \015", line2 ); break;
                   case COLUMN1_SOURCE          :  StrCopy( (BIT8 *)"C1 source           \015", line2 ); break;
                   case COLUMN1_OUTLET          :  StrCopy( (BIT8 *)"C1 outlet           \015", line2 ); break;
                   case COLUMN1_VACUUM_COMP     :  StrCopy( (BIT8 *)"C1 vacuum comp      \015", line2 ); break;
                   case COLUMN1_PRES_COMP_SETPT :  StrCopy( (BIT8 *)"C1 pres comp setpt  \015", line2 ); break;
                   case COLUMN1_OUTLET_PRES_COMP:  StrCopy( (BIT8 *)"C1 pres comp        \015", line2 ); break;
                   case COLUMN2_LENGTH          :  StrCopy( (BIT8 *)"C2 length           \015", line2 ); break;
                   case COLUMN2_DIAM            :  StrCopy( (BIT8 *)"C2 diam             \015", line2 ); break;
                   case COLUMN2_FILM_THICK      :  StrCopy( (BIT8 *)"C2 film thick       \015", line2 ); break;
                   case COLUMN2_SOURCE          :  StrCopy( (BIT8 *)"C2 source           \015", line2 ); break;
                   case COLUMN2_OUTLET          :  StrCopy( (BIT8 *)"C2 outlet           \015", line2 ); break;
                   case COLUMN2_VACUUM_COMP     :  StrCopy( (BIT8 *)"C2 vacuum comp      \015", line2 ); break;
                   case COLUMN2_PRES_COMP_SETPT :  StrCopy( (BIT8 *)"C2 pres comp setpt  \015", line2 ); break;
                   case COLUMN2_OUTLET_PRES_COMP:  StrCopy( (BIT8 *)"C2 pres comp        \015", line2 ); break;
                   }

                   StrCopy(    (BIT8 *)Pneu_Messages[201], line3 );
                   StrCopy(    (BIT8 *)Pneu_Messages[202], line4 );

                   FakeIntFormat ( Active_Error_Line,                             &line1[ 8] );
                   FormatHex     ( meth_error_list[ Active_Error_Line ].current,  &line3[ 5] );
                   FormatHex     ( meth_error_list[ Active_Error_Line ].method,   &line4[ 5] );
                   FakeIntFormat ( meth_error_list[ Active_Error_Line ].current,  &line3[13] );
                   FakeIntFormat ( meth_error_list[ Active_Error_Line ].method,   &line4[13] );
                }

                BuildStringImage( line1, line2, line3, line4 );
                break;



         case FI_FS:
         case BI_FS:
                status = (Object == FI_FS) ? &Inst_Status.Pneu.Frnt_Inlet : &Inst_Status.Pneu.Back_Inlet;

                StrCopy(    (BIT8 *)Pneu_Messages[84], line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[85], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[86], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[87], line4 );

                FakeRealFormat( ((INT32)status->Tcomp_Tables->Flow_Sensor.Flow_Setpt * 100 /
                                          (INT32)status->IU_Scaling), 100, &line1[12]);

                FakeRealFormat( (INT32)status->Tcomp_Tables->Flow_Sensor.Volts_Setpt * 1000 / 13107, 1000,  &line2[12] );
                FakeRealFormat( (INT32)status->Tcomp_Tables->Flow_Sensor.dV_Setpt * 10000 / 13107, 10000,   &line3[12] );
                FormatHexHalfWord  ( status->Tcomp_Tables->Flow_Sensor.Total_Volts_Setpt,  &line4[15] );


                FakeRealFormat( ((INT32)status->Tcomp_Tables->Flow_Sensor.Flow_Actual * 100 /
                                          (INT32)status->IU_Scaling), 100, &line1[ 4]);

                FakeRealFormat( (INT32)status->Tcomp_Tables->Flow_Sensor.Volts_Actual * 1000 / 13107, 1000,  &line2[ 4] );
                FakeRealFormat( (INT32)status->Tcomp_Tables->Flow_Sensor.dV_Actual * 10000 / 13107, 10000,   &line3[ 4] );
                FormatHexHalfWord  ( status->Tcomp_Tables->Flow_Sensor.Total_Volts_Actual,  &line4[ 7] );

                BuildStringImage( line1, line2, line3, line4 );
                break;



         case FI_PS:
         case BI_PS:
                status = (Object == FI_PS) ? &Inst_Status.Pneu.Frnt_Inlet : &Inst_Status.Pneu.Back_Inlet;

                StrCopy(    (BIT8 *)Pneu_Messages[88], line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[89], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[90], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[91], line4 );

                FakeRealFormat( ((U_INT32)status->Tcomp_Tables->Pres_Sensor.Pres_Setpt * 100 *
                                          status->Dcm2_Per_IU / 68947 ), 100, &line1[12]);

                FakeRealFormat( (INT32)status->Tcomp_Tables->Pres_Sensor.Pres_Volts_Setpt * 1000 / 13107, 1000, &line2[12] );
                FakeRealFormat( (INT32)status->Tcomp_Tables->Pres_Sensor.Pres_dV_Setpt * 10000 / 13107, 10000,  &line3[12] );
                FormatHexHalfWord  ( status->Tcomp_Tables->Pres_Sensor.Pres_Adc_Setpt,  &line4[15] );


                FakeRealFormat( ((INT32)status->Tcomp_Tables->Pres_Sensor.Pres_Actual *  100 *
                                          (INT16)status->Dcm2_Per_IU / 68947 ), 100, &line1[ 4]);

                FakeRealFormat( (INT32)status->Tcomp_Tables->Pres_Sensor.Pres_Volts_Actual * 1000 / 13107, 1000, &line2[ 4] );
                FakeRealFormat( (INT32)status->Tcomp_Tables->Pres_Sensor.Pres_dV_Actual * 10000 / 13107, 10000,  &line3[ 4] );
                FormatHexHalfWord  ( status->Tcomp_Tables->Pres_Sensor.Pres_Adc_Actual,  &line4[ 7] );

                BuildStringImage( line1, line2, line3, line4 );
                break;


         case Aux3_V:
         case Aux4_V:
         case Aux5_V:


                junk_ptr = (Object == Aux3_V) ? &Inst_Status.Pneu.Aux.Tcomp_Tables->Aux_3  :
                           (Object == Aux4_V) ? &Inst_Status.Pneu.Aux.Tcomp_Tables->Aux_4  :
                                                &Inst_Status.Pneu.Aux.Tcomp_Tables->Aux_5 ;

                astatus  = (Object == Aux3_V) ? &Inst_Status.Pneu.Aux.Aux_3  :
                           (Object == Aux4_V) ? &Inst_Status.Pneu.Aux.Aux_4  :
                                                &Inst_Status.Pneu.Aux.Aux_5 ;

                StrCopy((BIT8 *)Pneu_Messages[ (Object == Aux3_V) ? 118  : (Object == Aux4_V) ? 119  : 120 ], line1 );

                StrCopy(    (BIT8 *)Pneu_Messages[89], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[90], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[91], line4 );

                FakeRealFormat( ((U_INT32)((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_Setpt
                                 * 100 * astatus->Dcm2_Per_IU / 68947 ), 100, &line1[12]);

                FakeRealFormat( (INT32)((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_Volts_Setpt
                                 * 1000 / 13107, 1000, &line2[12] );

                FakeRealFormat( (INT32)((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_dV_Setpt
                                 * 10000 / 13107, 10000,  &line3[12] );

                FormatHexHalfWord  ( ((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_Adc_Setpt,
                                 &line4[15] );


                FakeRealFormat( ((INT32)((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_Actual
                                 *  100 * astatus->Dcm2_Per_IU / 68947 ), 100, &line1[ 4]);

                FakeRealFormat( (INT32)((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_Volts_Actual
                                 * 1000 / 13107, 1000, &line2[ 4] );

                FakeRealFormat( (INT32)((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_dV_Actual
                                 * 10000 / 13107, 10000,  &line3[ 4] );

                FormatHexHalfWord  ( ((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_Adc_Actual,
                                 &line4[ 7] );

                BuildStringImage( line1, line2, line3, line4 );
                break;


         case FD_G1_V:
         case FD_G2_V:
         case FD_G3_V:
         case BD_G1_V:
         case BD_G2_V:
         case BD_G3_V:

                junk_ptr = (Object == FD_G1_V) ? &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Fuel.Pres_Sensor :
                           (Object == FD_G2_V) ? &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Util.Pres_Sensor :
                           (Object == FD_G3_V) ? &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Mug.Pres_Sensor  :
                           (Object == BD_G1_V) ? &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Fuel.Pres_Sensor :
                           (Object == BD_G2_V) ? &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Util.Pres_Sensor :
                                                 &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Mug.Pres_Sensor   ;

                i        = (Object == FD_G1_V) ?  Inst_Status.Pneu.Frnt_Detector.Gas_1.Dcm2_Per_IU    :
                           (Object == FD_G2_V) ?  Inst_Status.Pneu.Frnt_Detector.Gas_2.Dcm2_Per_IU    :
                           (Object == FD_G3_V) ?  Inst_Status.Pneu.Frnt_Detector.Gas_3.Dcm2_Per_IU    :
                           (Object == BD_G1_V) ?  Inst_Status.Pneu.Back_Detector.Gas_1.Dcm2_Per_IU    :
                           (Object == BD_G2_V) ?  Inst_Status.Pneu.Back_Detector.Gas_2.Dcm2_Per_IU    :
                                                  Inst_Status.Pneu.Back_Detector.Gas_3.Dcm2_Per_IU    ;

                StrCopy((BIT8 *)Pneu_Messages[ (Object == FD_G1_V) ? 279  :
                                               (Object == FD_G2_V) ? 280  :
                                               (Object == FD_G3_V) ? 281  :
                                               (Object == BD_G1_V) ? 282  :
                                               (Object == BD_G2_V) ? 283  :
                                                                     284 ], line1 );

                StrCopy(    (BIT8 *)Pneu_Messages[89], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[90], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[91], line4 );

                FakeRealFormat( ((U_INT32)((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_Setpt
                                 * 100 * (long)i / 68947 ), 100, &line1[12]);

                FakeRealFormat( (INT32)((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_Volts_Setpt
                                 * 1000 / 13107, 1000, &line2[12] );

                FakeRealFormat( (INT32)((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_dV_Setpt
                                 * 10000 / 13107, 10000,  &line3[12] );

                FormatHexHalfWord  ( ((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_Adc_Setpt,
                                 &line4[15] );


                FakeRealFormat( ((INT32)((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_Actual
                                 *  100 * (long)i / 68947 ), 100, &line1[ 4]);

                FakeRealFormat( (INT32)((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_Volts_Actual
                                 * 1000 / 13107, 1000, &line2[ 4] );

                FakeRealFormat( (INT32)((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_dV_Actual
                                 * 10000 / 13107, 10000,  &line3[ 4] );

                FormatHexHalfWord  ( ((pPRES_SENSOR_STRUCT)junk_ptr)->Pres_Adc_Actual,
                                 &line4[ 7] );

                BuildStringImage( line1, line2, line3, line4 );
                break;



         case FI_Flow:
         case BI_Flow:
                status = (Object == FI_Flow) ? &Inst_Status.Pneu.Frnt_Inlet : &Inst_Status.Pneu.Back_Inlet;

                StrCopy(    (BIT8 *)Pneu_Messages[135], line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[136], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[137], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[138], line4 );

                FakeRealFormat( QuadWordMultiplyDivide( status->Column, 1000, status->IU_Scaling),
                                 1000, &line1[ 4]);
                FakeRealFormat( QuadWordMultiplyDivide( status->Septum, 1000, status->IU_Scaling),
                                 1000, &line2[ 4]);
                FakeRealFormat( QuadWordMultiplyDivide( status->Split,  1000, status->IU_Scaling),
                                 1000, &line3[ 4]);
                FakeRealFormat( QuadWordMultiplyDivide( status->Total,  1000, status->IU_Scaling),
                                 1000, &line4[ 4]);

                FakeRealFormat( QuadWordMultiplyDivide( status->Ntp_Column, 1000, status->IU_Scaling),
                                 1000, &line1[12]);
                FakeRealFormat( QuadWordMultiplyDivide( status->Septum,     1000, status->IU_Scaling),
                                 1000, &line2[12]);
                FakeRealFormat( QuadWordMultiplyDivide( status->Ntp_Split,  1000, status->IU_Scaling),
                                 1000, &line3[12]);
                FakeRealFormat( QuadWordMultiplyDivide( status->Ntp_Total,  1000, status->IU_Scaling),
                                 1000, &line4[12]);

                BuildStringImage( line1, line2, line3, line4 );
                break;


         case C1_Setpt:
         case C2_Setpt:
                cstatus = (Object == C1_Setpt) ? &Inst_Status.Pneu.Column_1 : &Inst_Status.Pneu.Column_2;

                StrCopy(    (BIT8 *)Pneu_Messages[ 98], line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[100], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[101], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[102], line4 );

                FakeRealFormat( QuadWordMultiplyDivide((U_INT32)cstatus->NTP_Pres_Setpt * 1000,
                                                       cstatus->Dcm2_Per_IU,
                                                       68947 ), 1000, &line2[12]);
                FakeRealFormat( QuadWordMultiplyDivide((U_INT32)cstatus->Pres_Setpt * 1000,
                                                       cstatus->Dcm2_Per_IU,
                                                       68947 ), 1000, &line2[ 4]);

                FakeRealFormat( QuadWordMultiplyDivide(cstatus->NTP_Flow_Setpt,
                                                       1000,
                                                       cstatus->IU_Scaling ), 1000, &line3[12]);
                FakeRealFormat( QuadWordMultiplyDivide(cstatus->Flow_Setpt,
                                                       1000,
                                                       cstatus->IU_Scaling ), 1000, &line3[ 4]);

                FakeRealFormat( QuadWordMultiplyDivide(cstatus->NTP_Uavg_Setpt,
                                                       1000,
                                                       cstatus->Vel_IU_Scaling ), 1000, &line4[12]);
                FakeRealFormat( QuadWordMultiplyDivide(cstatus->Uavg_Setpt,
                                                       1000,
                                                       cstatus->Vel_IU_Scaling ), 1000, &line4[ 4]);

                BuildStringImage( line1, line2, line3, line4 );
                break;


         case C1_Actual:
         case C2_Actual:
                cstatus = (Object == C1_Actual) ? &Inst_Status.Pneu.Column_1 : &Inst_Status.Pneu.Column_2;

                StrCopy(    (BIT8 *)Pneu_Messages[ 99], line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[100], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[101], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[102], line4 );

                FakeRealFormat( QuadWordMultiplyDivide((U_INT32)cstatus->NTP_Pres_Actual * 1000,
                                                       cstatus->Dcm2_Per_IU,
                                                       68947 ), 1000, &line2[12]);
                FakeRealFormat( QuadWordMultiplyDivide((U_INT32)cstatus->Pres_Actual * 1000,
                                                       cstatus->Dcm2_Per_IU,
                                                       68947 ), 1000, &line2[ 4]);

                FakeRealFormat( QuadWordMultiplyDivide(cstatus->NTP_Flow_Actual,
                                                       1000,
                                                       cstatus->IU_Scaling ), 1000, &line3[12]);
                FakeRealFormat( QuadWordMultiplyDivide(cstatus->Flow_Actual,
                                                       1000,
                                                       cstatus->IU_Scaling ), 1000, &line3[ 4]);

                FakeRealFormat( QuadWordMultiplyDivide(cstatus->NTP_Uavg_Actual,
                                                       1000,
                                                       cstatus->Vel_IU_Scaling ), 1000, &line4[12]);
                FakeRealFormat( QuadWordMultiplyDivide(cstatus->Uavg_Actual,
                                                       1000,
                                                       cstatus->Vel_IU_Scaling ), 1000, &line4[ 4]);

                BuildStringImage( line1, line2, line3, line4 );
                break;



         case FD_G1:
         case FD_G2:
         case FD_G3:
         case BD_G1:
         case BD_G2:
         case BD_G3:

                StrCopy(    (BIT8 *)Pneu_Messages[69],                                                  line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[70],                                                   line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[71],                                                   line4 );

                switch ( Object )
                {
                default:
                case FD_G1:  gas_table = &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Fuel;
                             StrCopy(    (BIT8 *)Pneu_Messages[72],  line1 );
                             break;
                case FD_G2:  gas_table = &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Util;
                             StrCopy(    (BIT8 *)Pneu_Messages[73],  line1 );
                             break;
                case FD_G3:  gas_table = &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Mug;
                             StrCopy(    (BIT8 *)Pneu_Messages[74],  line1 );
                             break;
                case BD_G1:  gas_table = &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Fuel;
                             StrCopy(    (BIT8 *)Pneu_Messages[75],  line1 );
                             break;
                case BD_G2:  gas_table = &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Util;
                             StrCopy(    (BIT8 *)Pneu_Messages[76],  line1 );
                             break;
                case BD_G3:  gas_table = &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Mug;
                             StrCopy(    (BIT8 *)Pneu_Messages[77],  line1 );
                             break;
                }


                FakeRealFormat( ((INT32)(gas_table->Frit.Pres_Setpt*16000/68947)), 100, &line1[12]);
                FormatHexHalfWord( (INT32)gas_table->Frit.UPres_Setpt, &line2[15] );
                FormatHexHalfWord( (INT32)gas_table->Frit.TCorr_Setpt, &line3[15] );
                FormatHexHalfWord( (INT32)gas_table->Frit.PCorr_Setpt, &line4[15] );

                FakeRealFormat( ((INT32)gas_table->Frit.Pres_Actual*16000/68947), 100, &line1[ 5]);
                FormatHexHalfWord( (INT32)gas_table->Frit.UPres_Actual, &line2[ 8] );
                FormatHexHalfWord( (INT32)gas_table->Frit.TCorr_Actual, &line3[ 8] );
                FormatHexHalfWord( (INT32)gas_table->Frit.PCorr_Actual, &line4[ 8] );

                BuildStringImage( line1, line2, line3, line4 );
                break;




         case FI_P_Ready:
         case BI_P_Ready:

                status = (Object == FI_P_Ready) ? &Inst_Status.Pneu.Frnt_Inlet : &Inst_Status.Pneu.Back_Inlet;

                if ( Object == FI_P_Ready )
                {
                    if ( status->Ready.Pres.Reported_Ready )
                        StrCopy(    (BIT8 *)Pneu_Messages[139], line1 );
                    else
                        StrCopy(    (BIT8 *)Pneu_Messages[140], line1 );
                }
                else
                {
                    if ( status->Ready.Pres.Reported_Ready )
                        StrCopy(    (BIT8 *)Pneu_Messages[141], line1 );
                    else
                        StrCopy(    (BIT8 *)Pneu_Messages[142], line1 );
                }

                StrCopy(    (BIT8 *)Pneu_Messages[  0], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[  0], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[  0], line4 );

                FakeRealFormat( QuadWordMultiplyDivide( status->Ready.Pres.Setpt,
                                                        100000L * status->Dcm2_Per_IU,
                                                        6894757 ),
                                     1000, &line2[12]);

                FakeRealFormat( QuadWordMultiplyDivide( status->Ready.Pres.Actual,
                                                        100000L * status->Dcm2_Per_IU,
                                                        6894757 ),
                                     1000, &line2[ 4]);

                FakeRealFormat( SignedQuadWordMultiplyDivide( status->Ready.Pres.Difference,
                                                        100000L * status->Dcm2_Per_IU,
                                                        6894757 ),
                                     1000, &line3[ 4]);

                FakeIntFormat    (  status->Ready.Pres.Tic_Counter, &line3[ 8] );
                FakeIntFormat    (  status->Ready.Pres.Timeout,     &line3[13] );


                if ((( Tick_512_Counter / 512 ) % 2 ) && ( status->Shutdown ))
                {
                     StrCopy( (BIT8 *)Pneu_Messages[173], line4 );
                }
                else
                {
                     StrCopyParm((BIT8 *)Ready_States[(U_INT8) status->Ready.Pres.State ], line4 );
                }

                BuildStringImage( line1, line2, line3, line4 );
                break;


         case FD_1P_Ready:
         case FD_2P_Ready:
         case FD_3P_Ready:
         case BD_1P_Ready:
         case BD_2P_Ready:
         case BD_3P_Ready:

                switch ( Object )
                {
                    default:
                    case FD_1P_Ready:
                    case FD_2P_Ready:
                    case FD_3P_Ready: dstatus = &Inst_Status.Pneu.Frnt_Detector;
                                      scratch[0] = 0;
                                      break;
                    case BD_1P_Ready:
                    case BD_2P_Ready:
                    case BD_3P_Ready: dstatus = &Inst_Status.Pneu.Back_Detector;
                                      scratch[0] = 1;
                                      break;
                }

                switch ( Object )
                {
                    case FD_1P_Ready:
                    case BD_1P_Ready: ready = &dstatus->Ready.Fuel_Pres;
                                      scratch[1] = 0;
                                      break;
                    case FD_2P_Ready:
                    case BD_2P_Ready: ready = &dstatus->Ready.Util_Pres;
                                      scratch[1] = 1;
                                      break;
                    default:
                    case FD_3P_Ready:
                    case BD_3P_Ready: ready = &dstatus->Ready.Mug_Pres;
                                      scratch[1] = 2;
                                      break;
                }


                if ( ready->Reported_Ready )
                    StrCopy(    (BIT8 *)Pneu_Messages[ Det_Ready_Msg_No [0] [scratch[0]] [scratch[1]] [0] ], line1 );
                else
                    StrCopy(    (BIT8 *)Pneu_Messages[ Det_Ready_Msg_No [0] [scratch[0]] [scratch[1]] [1] ], line1 );

                StrCopy(    (BIT8 *)Pneu_Messages[  0], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[  0], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[  0], line4 );

                switch ( Object )
                {
                    case FD_1P_Ready:
                    case BD_1P_Ready: scratch[0] = dstatus->Gas_1.Dcm2_Per_IU;
                                      break;
                    case FD_2P_Ready:
                    case BD_2P_Ready: scratch[0] = dstatus->Gas_2.Dcm2_Per_IU;
                                      break;
                    case FD_3P_Ready:
                    case BD_3P_Ready: scratch[0] = dstatus->Gas_3.Dcm2_Per_IU;
                                      break;
                }

                FakeRealFormat( QuadWordMultiplyDivide( ready->Setpt,
                                                        100000L * scratch[0],
                                                        6894757 ),
                                     1000, &line2[12]);

                FakeRealFormat( QuadWordMultiplyDivide( ready->Actual,
                                                        100000L * scratch[0],
                                                        6894757 ),
                                     1000, &line2[ 4]);

                FakeRealFormat( SignedQuadWordMultiplyDivide( ready->Difference,
                                                        100000L * scratch[0],
                                                        6894757 ),
                                     1000, &line3[ 4]);

                FakeIntFormat    (  ready->Tic_Counter, &line3[ 8] );
                FakeIntFormat    (  ready->Timeout,     &line3[13] );


                if ((( Tick_512_Counter / 512 ) % 2 ) && ( dstatus->Shutdown ))
                {
                     StrCopy( (BIT8 *)Pneu_Messages[173], line4 );
                }
                else
                {
                     StrCopyParm((BIT8 *)Ready_States[ (U_INT8)ready->State ], line4 );
                }

                BuildStringImage( line1, line2, line3, line4 );
                break;



         case FD_1F_Ready:
         case FD_2F_Ready:
         case FD_3F_Ready:
         case BD_1F_Ready:
         case BD_2F_Ready:
         case BD_3F_Ready:

                switch ( Object )
                {
                    default:
                    case FD_1F_Ready:
                    case FD_2F_Ready:
                    case FD_3F_Ready: dstatus = &Inst_Status.Pneu.Frnt_Detector;
                                      scratch[0] = 0;
                                      break;
                    case BD_1F_Ready:
                    case BD_2F_Ready:
                    case BD_3F_Ready: dstatus = &Inst_Status.Pneu.Back_Detector;
                                      scratch[0] = 1;
                                      break;
                }

                switch ( Object )
                {
                    case FD_1F_Ready:
                    case BD_1F_Ready: ready = &dstatus->Ready.Fuel_Flow;
                                      scratch[1] = 0;
                                      break;
                    case FD_2F_Ready:
                    case BD_2F_Ready: ready = &dstatus->Ready.Util_Flow;
                                      scratch[1] = 1;
                                      break;
                    default:
                    case FD_3F_Ready:
                    case BD_3F_Ready: ready = &dstatus->Ready.Mug_Flow;
                                      scratch[1] = 2;
                                      break;
                }


                if ( ready->Reported_Ready )
                    StrCopy(    (BIT8 *)Pneu_Messages[ Det_Ready_Msg_No [1] [scratch[0]] [scratch[1]] [0] ], line1 );
                else
                    StrCopy(    (BIT8 *)Pneu_Messages[ Det_Ready_Msg_No [1] [scratch[0]] [scratch[1]] [1] ], line1 );

                StrCopy(    (BIT8 *)Pneu_Messages[  0], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[  0], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[  0], line4 );

                switch ( Object )
                {
                    case FD_1F_Ready:
                    case BD_1F_Ready: scratch[0] = dstatus->IU_Scaling;
                                      break;
                    case FD_2F_Ready:
                    case BD_2F_Ready: scratch[0] = dstatus->IU_Scaling;
                                      break;
                    case FD_3F_Ready:
                    case BD_3F_Ready: scratch[0] = dstatus->IU_Scaling;
                                      break;
                }

                FakeRealFormat( QuadWordMultiplyDivide( ready->Setpt, 1000,  scratch[0]),
                                     1000, &line2[12]);

                FakeRealFormat( QuadWordMultiplyDivide( ready->Actual, 1000, scratch[0]),
                                     1000, &line2[ 4]);

                FakeRealFormat( SignedQuadWordMultiplyDivide( ready->Difference, 1000, scratch[0]),
                                     1000, &line3[ 4]);

                FakeIntFormat    (  ready->Tic_Counter, &line3[ 8] );
                FakeIntFormat    (  ready->Timeout,     &line3[13] );


                if ((( Tick_512_Counter / 512 ) % 2 ) && ( dstatus->Shutdown ))
                {
                     StrCopy( (BIT8 *)Pneu_Messages[173], line4 );
                }
                else
                {
                     StrCopyParm((BIT8 *)Ready_States[ (U_INT8)ready->State ], line4 );
                }

                BuildStringImage( line1, line2, line3, line4 );
                break;


         case Aux3_Ready:
         case Aux4_Ready:
         case Aux5_Ready:

                switch ( Object )
                {
                    default:
                    case Aux3_Ready: astatus = &Inst_Status.Pneu.Aux.Aux_3;
                                     if ( astatus->Ready.Pres.Reported_Ready )
                                           StrCopy(    (BIT8 *)Pneu_Messages[167], line1 );
                                     else
                                           StrCopy(    (BIT8 *)Pneu_Messages[168], line1 );
                                     break;
                    case Aux4_Ready: astatus = &Inst_Status.Pneu.Aux.Aux_4;
                                     if ( astatus->Ready.Pres.Reported_Ready )
                                           StrCopy(    (BIT8 *)Pneu_Messages[169], line1 );
                                     else
                                           StrCopy(    (BIT8 *)Pneu_Messages[170], line1 );
                                     break;
                    case Aux5_Ready: astatus = &Inst_Status.Pneu.Aux.Aux_5;
                                     if ( astatus->Ready.Pres.Reported_Ready )
                                           StrCopy(    (BIT8 *)Pneu_Messages[171], line1 );
                                     else
                                           StrCopy(    (BIT8 *)Pneu_Messages[172], line1 );
                                     break;
                }


                StrCopy(    (BIT8 *)Pneu_Messages[  0], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[  0], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[  0], line4 );

                FakeRealFormat( QuadWordMultiplyDivide( astatus->Ready.Pres.Setpt,
                                                        100000L * astatus->Dcm2_Per_IU,
                                                        6894757 ),
                                     1000, &line2[12]);

                FakeRealFormat( QuadWordMultiplyDivide( astatus->Ready.Pres.Actual,
                                                        100000L * astatus->Dcm2_Per_IU,
                                                        6894757 ),
                                     1000, &line2[ 4]);

                FakeRealFormat( SignedQuadWordMultiplyDivide( astatus->Ready.Pres.Difference,
                                                        100000L * astatus->Dcm2_Per_IU,
                                                        6894757 ),
                                     1000, &line3[ 4]);

                FakeIntFormat    (  astatus->Ready.Pres.Tic_Counter, &line3[ 8] );
                FakeIntFormat    (  astatus->Ready.Pres.Timeout,     &line3[13] );


                if ((( Tick_512_Counter / 512 ) % 2 ) && ( astatus->Shutdown ))
                {
                     StrCopy( (BIT8 *)Pneu_Messages[173], line4 );
                }
                else
                {
                     StrCopyParm((BIT8 *)Ready_States[ (U_INT8)astatus->Ready.Pres.State ], line4 );
                }


                BuildStringImage( line1, line2, line3, line4 );
                break;




         case FI_F_Ready:
         case BI_F_Ready:

                status = (Object == FI_F_Ready) ? &Inst_Status.Pneu.Frnt_Inlet : &Inst_Status.Pneu.Back_Inlet;

                if ( Object == FI_F_Ready )
                {
                    if ( status->Ready.Flow.Reported_Ready )
                        StrCopy(    (BIT8 *)Pneu_Messages[143], line1 );
                    else
                        StrCopy(    (BIT8 *)Pneu_Messages[144], line1 );
                }
                else
                {
                    if ( status->Ready.Flow.Reported_Ready )
                        StrCopy(    (BIT8 *)Pneu_Messages[145], line1 );
                    else
                        StrCopy(    (BIT8 *)Pneu_Messages[146], line1 );
                }

                StrCopy(    (BIT8 *)Pneu_Messages[  0], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[  0], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[  0], line4 );

                FakeRealFormat( QuadWordMultiplyDivide( status->Ready.Flow.Setpt,
                                                        1000,
                                                        status->IU_Scaling ),
                                     1000, &line2[12]);

                FakeRealFormat( QuadWordMultiplyDivide( status->Ready.Flow.Actual,
                                                        1000,
                                                        status->IU_Scaling ),
                                     1000, &line2[ 4]);

                FakeRealFormat( SignedQuadWordMultiplyDivide( status->Ready.Flow.Difference,
                                                        1000,
                                                        status->IU_Scaling ),
                                     1000, &line3[ 4]);

                FakeIntFormat    (  status->Ready.Flow.Tic_Counter, &line3[ 8] );
                FakeIntFormat    (  status->Ready.Flow.Timeout,     &line3[13] );

                if ((( Tick_512_Counter / 512 ) % 2 ) && ( status->Shutdown ))
                {
                     StrCopy( (BIT8 *)Pneu_Messages[173], line4 );
                }
                else
                {
                     StrCopyParm((BIT8 *)Ready_States[ (U_INT8)status->Ready.Flow.State ], line4 );
                }


                BuildStringImage( line1, line2, line3, line4 );
                break;

         case FI_FS_Parms:
         case BI_FS_Parms:

                status = (Object == FI_FS_Parms) ? &Inst_Status.Pneu.Frnt_Inlet : &Inst_Status.Pneu.Back_Inlet;

                StrCopy(    (BIT8 *)Pneu_Messages[151], line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[152], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[153], line3 );
                StrCopy(    (BIT8 *)Pneu_Messages[154], line4 );

                FakeRealFormat ( (INT32)(status->Tcomp_Tables->Flow_Sensor.Parms.Alpha_Low  * 1000.0 / 13107.0),
                                          1000, &line1[ 3] );
                FakeRealFormat ( (INT32)(status->Tcomp_Tables->Flow_Sensor.Parms.Alpha_High * 1000.0 / 13107.0),
                                          1000, &line1[12] );

                FakeRealFormat ( (INT32)(status->Tcomp_Tables->Flow_Sensor.Parms.Beta_Low  * 1000000.0),
                                         1000000, &line2[ 3]  );
                FakeRealFormat ( (INT32)(status->Tcomp_Tables->Flow_Sensor.Parms.Beta_High * 1000000.0),
                                         1000000, &line2[12]  );

                FakeRealFormat ( (INT32)(status->Tcomp_Tables->Flow_Sensor.Parms.Offset * 1000.0 / 13107.0),
                                           1000, &line3[12] );
                FormatHexHalfWord( status->Tcomp_Tables->Flow_Sensor.Parms.Offset,  &line3[ 6] );

                FakeRealFormat ( (INT32)status->Tcomp_Tables->Flow_Sensor.Parms.High_Flow, 1, &line4[12]  );
                FormatHexHalfWord( status->Tcomp_Tables->Flow_Sensor.Parms.High_Volts, &line4[ 6] );




                BuildStringImage( line1, line2, line3, line4 );
                break;



        case FI_Hdr:
        case BI_Hdr:
        case FD_Hdr:
        case BD_Hdr:
        case AX_Hdr:
                         switch ( Object )
                         {
                             case FI_Hdr: StrCopy( (BIT8 *)Pneu_Messages[229], line1 );
                                          break;
                             case BI_Hdr: StrCopy( (BIT8 *)Pneu_Messages[230], line1 );
                                          break;
                             case FD_Hdr: StrCopy( (BIT8 *)Pneu_Messages[231], line1 );
                                          break;
                             case BD_Hdr: StrCopy( (BIT8 *)Pneu_Messages[232], line1 );
                                          break;
                             case AX_Hdr: StrCopy( (BIT8 *)Pneu_Messages[233], line1 );
                                          break;
                         }

                         StrCopy( (BIT8 *)Pneu_Messages[234], line2 );
                         StrCopy( (BIT8 *)Pneu_Messages[235], line3 );
                         StrCopy( (BIT8 *)Pneu_Messages[236], line4 );


                         if ( (( Object == FI_Hdr ) || ( Object == BI_Hdr )) &&
                              (
                              !(((ser_no_low  % 0x0100 >= 0x30) && (ser_no_low  % 0x0100 <= 0x5a)) ||
                                ((ser_no_low  % 0x0100 >= 0x61) && (ser_no_low  % 0x0100 <= 0x7a)) ) ||

                              !(((ser_no_low  / 0x0100 >= 0x30) && (ser_no_low  / 0x0100 <= 0x5a)) ||
                                ((ser_no_low  / 0x0100 >= 0x61) && (ser_no_low  / 0x0100 <= 0x7a)) ) ||

                              !(((ser_no_high % 0x0100 >= 0x30) && (ser_no_high % 0x0100 <= 0x5a)) ||
                                ((ser_no_high % 0x0100 >= 0x61) && (ser_no_high % 0x0100 <= 0x7a)) ) ||

                              !(((ser_no_high / 0x0100 >= 0x30) && (ser_no_high / 0x0100 <= 0x5a)) ||
                                ((ser_no_high / 0x0100 >= 0x61) && (ser_no_high / 0x0100 <= 0x7a)) ) ))

                         {
                             FakeRealFormat ( ser_no_high * 65536 + ser_no_low, 1, &line2[12]  );
                         }
                         else
                         {
                             line2[18] =  (ser_no_low  % 0x0100 >= 0x30) ? ser_no_low  % 0x0100 : 0x30;
                             line2[17] =  (ser_no_low  / 0x0100 >= 0x30) ? ser_no_low  / 0x0100 : 0x30;
                             line2[16] =  (ser_no_high % 0x0100 >= 0x30) ? ser_no_high % 0x0100 : 0x30;
                             line2[15] =  (ser_no_high / 0x0100 >= 0x30) ? ser_no_high / 0x0100 : 0x30;
                         }

                         line3[12] =  ((build_date >> 11) % 10 ) + '0';
                         line3[11] =  ((build_date >> 11) / 10 ) + '0';

                         line3[15] =  (((build_date & 0x0780) >>  7) % 10 ) + '0';
                         line3[14] =  (((build_date & 0x0780) >>  7) / 10 ) + '0';

                         line3[18] =  ((((build_date & 0x007f) + 80 ) % 10 )      ) + '0';
                         line3[17] =  ((((build_date & 0x007f) + 80 ) / 10 ) % 10 ) + '0';


                         FormatHexHalfWord( test_station_id, &line4[15] );


                         BuildStringImage( line1, line2, line3, line4 );
                         break;



        case FI_Therm:
        case BI_Therm:
        case FD_Therm:
        case BD_Therm:
        case Aux_Therm:
                         switch ( Object )
                         {
                             default:
                             case FI_Therm: therm = &Inst_Status.Pneu.Frnt_Inlet.Tcomp_Tables->Thermistor.Parms;
                                            break;
                             case BI_Therm: therm = &Inst_Status.Pneu.Back_Inlet.Tcomp_Tables->Thermistor.Parms;
                                            break;
                             case FD_Therm: therm = &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Thermistor.Parms;
                                            break;
                             case BD_Therm: therm = &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Thermistor.Parms;
                                            break;
                             case Aux_Therm: therm = &Inst_Status.Pneu.Aux.Tcomp_Tables->Thermistor.Parms;
                                            break;
                         }

                         StrCopy( (BIT8 *)Pneu_Messages[198], line1 );
                         StrCopy( (BIT8 *)Pneu_Messages[204], line2 );
                         StrCopy( (BIT8 *)Pneu_Messages[205], line3 );
                         StrCopy( (BIT8 *)Pneu_Messages[203], line4 );

                         FakeRealFormat   ( (INT32)((float)therm->dV/therm->dT * 64.0 * 1000.0 / 13107.0), 1000, &line1[12]  );

                         FakeRealFormat   ( (INT32)(therm->dV * 1000.0 / 13107.0), 1000, &line2[12]  );
                         FormatHexHalfWord( therm->dV, &line2[ 7] );

                         FakeRealFormat   ( (INT32)(therm->dT * 1000.0 / 64.0), 1000, &line3[12]  );
                         FormatHexHalfWord( therm->dT, &line3[ 7] );

                         FakeRealFormat   ( (INT32)(therm->V_25C * 1000.0 / 13107.0), 1000, &line4[12]  );
                         FormatHexHalfWord( therm->V_25C, &line4[ 7] );

                         BuildStringImage( line1, line2, line3, line4 );
                         break;

        case FI_PS_Terms:
        case BI_PS_Terms:
        case FD_PS_1:
        case FD_PS_2:
        case FD_PS_3:
        case BD_PS_1:
        case BD_PS_2:
        case BD_PS_3:
        case A3_PS:
        case A4_PS:
        case A5_PS:      switch ( Object )
                        {
                             default:
                             case FI_PS_Terms:StrCopy( (BIT8 *)Pneu_Messages[206], line1 );
                                            ps = &Inst_Status.Pneu.Frnt_Inlet.Tcomp_Tables->Pres_Sensor.Parms;
                                            break;
                             case BI_PS_Terms:StrCopy( (BIT8 *)Pneu_Messages[207], line1 );
                                            ps = &Inst_Status.Pneu.Back_Inlet.Tcomp_Tables->Pres_Sensor.Parms;
                                            break;

                             case FD_PS_1:StrCopy( (BIT8 *)Pneu_Messages[208], line1 );
                                            ps = &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Fuel.Pres_Sensor.Parms;
                                            break;
                             case FD_PS_2: StrCopy( (BIT8 *)Pneu_Messages[209], line1 );
                                            ps = &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Util.Pres_Sensor.Parms;
                                            break;
                             case FD_PS_3:StrCopy( (BIT8 *)Pneu_Messages[210], line1 );
                                            ps = &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Mug.Pres_Sensor.Parms;
                                            break;

                             case BD_PS_1:StrCopy( (BIT8 *)Pneu_Messages[211], line1 );
                                            ps = &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Fuel.Pres_Sensor.Parms;
                                            break;
                             case BD_PS_2: StrCopy( (BIT8 *)Pneu_Messages[212], line1 );
                                            ps = &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Util.Pres_Sensor.Parms;
                                            break;
                             case BD_PS_3: StrCopy( (BIT8 *)Pneu_Messages[213], line1 );
                                            ps = &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Mug.Pres_Sensor.Parms;
                                            break;

                             case A3_PS:StrCopy( (BIT8 *)Pneu_Messages[214], line1 );
                                            ps = &Inst_Status.Pneu.Aux.Tcomp_Tables->Aux_3.Parms;
                                            break;
                             case A4_PS:StrCopy( (BIT8 *)Pneu_Messages[215], line1 );
                                            ps = &Inst_Status.Pneu.Aux.Tcomp_Tables->Aux_3.Parms;
                                            break;
                             case A5_PS: StrCopy( (BIT8 *)Pneu_Messages[216], line1 );
                                            ps = &Inst_Status.Pneu.Aux.Tcomp_Tables->Aux_3.Parms;
                                            break;
                         }


                         StrCopy( (BIT8 *)Pneu_Messages[217], line2 );
                         StrCopy( (BIT8 *)Pneu_Messages[218], line3 );
                         StrCopy( (BIT8 *)Pneu_Messages[219], line4 );

                         FakeRealFormat   ( (INT32)ps->Offset * 1000 / 13107, 1000, &line1[11]  );
                         FormatHexHalfWord( ps->Offset, &line1[ 7] );

                         FakeRealFormat   ( (INT32)ps->Span * 1000 / 13107, 1000, &line2[11]  );
                         FormatHexHalfWord( ps->Span, &line2[ 7] );

                         FakeRealFormat   ( (INT32)ps->dOffset_dT * 64 *10000 / (13107 * 16384), 10000, &line3[12]  );
                         FormatHexHalfWord( ps->dOffset_dT, &line3[ 7] );

                         FakeRealFormat   ( (INT32)ps->dSpan_dT   * 64 *10000 / (13107 * 16384), 10000, &line4[12]  );
                         FormatHexHalfWord( ps->dSpan_dT, &line4[ 7] );


                         BuildStringImage( line1, line2, line3, line4 );

                         break;


        case FI_SPR:
        case BI_SPR:
                         switch ( Object )
                         {
                             default:
                             case FI_SPR:   StrCopy( (BIT8 *)Pneu_Messages[239], line1 );
                                            status = &Inst_Status.Pneu.Frnt_Inlet;
                                            spr = &Inst_Status.Pneu.Frnt_Inlet.Tcomp_Tables->Purge_Regulator;
                                            break;
                             case BI_SPR:   StrCopy( (BIT8 *)Pneu_Messages[239], line1 );
                                            status = &Inst_Status.Pneu.Back_Inlet;
                                            spr = &Inst_Status.Pneu.Back_Inlet.Tcomp_Tables->Purge_Regulator;
                                            break;
                         }

                         StrCopy( (BIT8 *)Pneu_Messages[237], line2 );
                         StrCopy( (BIT8 *)Pneu_Messages[238], line3 );
                         StrCopy( (BIT8 *)Pneu_Messages[  0], line4 );


                         FakeRealFormat( (INT32)(spr->Parms[ (U_INT8)status->Config->Gas_Type].Purge_Flow
                                                  * 1000 / status->IU_Scaling),
                                          1000, &line2[12]  );


                         FakeRealFormat( (INT32) SignedQuadWordMultiplyDivide(
                                                           spr->Parms[(U_INT8)status->Config->Gas_Type].dFlow_dPres * 1000,
                                                           ConvertPresDcuToIu( 68948, status->Dcm2_Per_IU),
                                                           DF_DP_SCALE * status->IU_Scaling ),
                                                  1000, &line3[12]  );

                         BuildStringImage( line1, line2, line3, line4 );
                         break;

        case FD_Frit_1:
        case FD_Frit_2:
        case FD_Frit_3:
        case BD_Frit_1:
        case BD_Frit_2:
        case BD_Frit_3:
                        switch ( Object )
                        {
                             case FD_Frit_1: StrCopy( (BIT8 *)Pneu_Messages[220], line1 );
                                             frit = &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Fuel.Frit.Parms;
                                             break;

                             case FD_Frit_2: StrCopy( (BIT8 *)Pneu_Messages[221], line1 );
                                             frit = &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Util.Frit.Parms;
                                             break;

                             default:
                             case FD_Frit_3: StrCopy( (BIT8 *)Pneu_Messages[222], line1 );
                                             frit = &Inst_Status.Pneu.Frnt_Detector.Tcomp_Tables->Mug.Frit.Parms;
                                             break;

                             case BD_Frit_1: StrCopy( (BIT8 *)Pneu_Messages[223], line1 );
                                             frit = &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Fuel.Frit.Parms;
                                             break;

                             case BD_Frit_2: StrCopy( (BIT8 *)Pneu_Messages[224], line1 );
                                             frit = &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Util.Frit.Parms;
                                             break;

                             case BD_Frit_3: StrCopy( (BIT8 *)Pneu_Messages[225], line1 );
                                             frit = &Inst_Status.Pneu.Back_Detector.Tcomp_Tables->Mug.Frit.Parms;
                                             break;

                        }

                        StrCopy( (BIT8 *)Pneu_Messages[226], line2 );
                        StrCopy( (BIT8 *)Pneu_Messages[227], line3 );
                        StrCopy( (BIT8 *)Pneu_Messages[  0], line4 );


                        FakeRealFormat ( (INT32)(frit->Alpha * 1000), 1000, &line2[12]  );
                        FakeRealFormat ( (INT32)(frit->Beta  * 1000), 1000, &line3[12]  );


                        BuildStringImage( line1, line2, line3, line4 );
                        break;

#define TICS_PER_CHAR  128
#define MAX_NAME_LEN        14
#define ITERATIONS_PER_NAME ( 20 + MAX_NAME_LEN )

         case Credits:
                        StrCopy( (BIT8 *)Pneu_Messages[252], line1 );
                        StrCopy( (BIT8 *)Pneu_Messages[253], line2 );
                        StrCopy( (BIT8 *)Pneu_Messages[  0], line4 );

                        if ((( Tick_512_Counter / (ITERATIONS_PER_NAME*TICS_PER_CHAR)) % 12 ) < 5 )
                           StrCopy( (BIT8 *)Pneu_Messages[254], line3 );
                        else
                           StrCopy( (BIT8 *)Pneu_Messages[255], line3 );

                        msg = 256 + (Tick_512_Counter / (ITERATIONS_PER_NAME*TICS_PER_CHAR)) % 6;

                        itr = (Tick_512_Counter % (ITERATIONS_PER_NAME*TICS_PER_CHAR)) / TICS_PER_CHAR;
                        for ( i = 0 ; i < MAX_NAME_LEN ; i++ )
                        {
                             if  ( (itr-MAX_NAME_LEN+i) > 19 ) continue;
                             if  ( (itr-MAX_NAME_LEN+i) < 0  ) continue;
                             line4[itr-MAX_NAME_LEN+i] = Pneu_Messages[msg][i];
                        }

                        BuildStringImage( line1, line2, line3, line4 );
                        break;

         case FI_Calib:
         case BI_Calib:
         case FD_Calib:
         case BD_Calib:
         case PA_Calib:

                status = NULL;   /* make lint happy, initialized for real below */

                switch ( Object )
                {
                  default:
                  case FI_Calib:
                  case BI_Calib:  status = (Object == FI_Calib) ? &Inst_Status.Pneu.Frnt_Inlet :
                                                                  &Inst_Status.Pneu.Back_Inlet ;
                                  calib.Pos_1.Gain   = status->Calib.P_Sensor_Gain;
                                  calib.Pos_1.Offset = status->Calib.P_Sensor_Offset;
                                  calib.Pos_1.Value  = status->Calib.Calib_Pressure;

                                  calib.Pos_2.Gain   = status->Calib.F_Sensor_Gain;
                                  calib.Pos_2.Offset = status->Calib.F_Sensor_Offset;
                                  calib.Pos_2.Value  = status->Calib.Calib_Flow;

                                  calib.Pos_3.Gain   = 0;
                                  calib.Pos_3.Offset = CALIB_GAIN_SCALING;
                                  calib.Pos_3.Value  = 0;
                                 break;
                  case FD_Calib:
                  case BD_Calib:  dstatus = (Object == FD_Calib) ? &Inst_Status.Pneu.Frnt_Detector :
                                                                   &Inst_Status.Pneu.Back_Detector ;
                                  calib.Pos_1.Gain   = dstatus->Gas_1.Calib.Gain;
                                  calib.Pos_1.Offset = dstatus->Gas_1.Calib.Offset;
                                  calib.Pos_1.Value  = dstatus->Gas_1.Calib.Flow;

                                  calib.Pos_2.Gain   = dstatus->Gas_2.Calib.Gain;
                                  calib.Pos_2.Offset = dstatus->Gas_2.Calib.Offset;
                                  calib.Pos_2.Value  = dstatus->Gas_2.Calib.Flow;

                                  calib.Pos_3.Gain   = dstatus->Gas_3.Calib.Gain;
                                  calib.Pos_3.Offset = dstatus->Gas_3.Calib.Offset;
                                  calib.Pos_3.Value  = dstatus->Gas_3.Calib.Flow;
                                 break;
                  case PA_Calib:
                                  calib.Pos_1.Gain   = Inst_Status.Pneu.Aux.Aux_3.Calib.Gain;
                                  calib.Pos_1.Offset = Inst_Status.Pneu.Aux.Aux_3.Calib.Offset;
                                  calib.Pos_1.Value  = Inst_Status.Pneu.Aux.Aux_3.Calib.Value;

                                  calib.Pos_2.Gain   = Inst_Status.Pneu.Aux.Aux_4.Calib.Gain;
                                  calib.Pos_2.Offset = Inst_Status.Pneu.Aux.Aux_4.Calib.Offset;
                                  calib.Pos_2.Value  = Inst_Status.Pneu.Aux.Aux_4.Calib.Value;

                                  calib.Pos_3.Gain   = Inst_Status.Pneu.Aux.Aux_5.Calib.Gain;
                                  calib.Pos_3.Offset = Inst_Status.Pneu.Aux.Aux_5.Calib.Offset;
                                  calib.Pos_3.Value  = Inst_Status.Pneu.Aux.Aux_5.Calib.Value;
                                 break;
                }

                StrCopy(    (BIT8 *)Pneu_Messages[262], line1 );
                StrCopy(    (BIT8 *)Pneu_Messages[263], line2 );
                StrCopy(    (BIT8 *)Pneu_Messages[264], line3 );

                if (( Object == FI_Calib ) || ( Object == BI_Calib ))
                {
                    status = (Object == FI_Calib) ? &Inst_Status.Pneu.Frnt_Inlet :
                                                                  &Inst_Status.Pneu.Back_Inlet ;
                    StrCopy(    (BIT8 *)Pneu_Messages[266], line4 );
                    FakeNumFormat( status->Last_Auto_Cal_Offset, &line4[18] );
                }
                else
                {
                    StrCopy(    (BIT8 *)Pneu_Messages[265], line4 );

                    FakeNumFormat( calib.Pos_3.Offset, &line4[7] );

                    FakeRealFormat( SignedQuadWordMultiplyDivide( (calib.Pos_3.Gain-CALIB_GAIN_SCALING)*100,
                                                             10000, CALIB_GAIN_SCALING ),
                                    10000, &line4[12] );
                }


                FakeNumFormat( calib.Pos_1.Offset, &line2[7] );
                FakeNumFormat( calib.Pos_2.Offset, &line3[7] );

                FakeRealFormat( SignedQuadWordMultiplyDivide( (calib.Pos_1.Gain-CALIB_GAIN_SCALING)*100,
                                                         10000, CALIB_GAIN_SCALING ),
                                10000, &line2[12] );
                FakeRealFormat( SignedQuadWordMultiplyDivide( (calib.Pos_2.Gain-CALIB_GAIN_SCALING)*100,
                                                         10000, CALIB_GAIN_SCALING ),
                                10000, &line3[12] );

                BuildStringImage( line1, line2, line3, line4 );
                break;

         case Test_Status:
#ifdef INCLUDE_PNEU_TEST
                            DisplayTestStatus();
#else
                            StrCopy(    (BIT8 *)Pneu_Messages[276], line1 );
                            StrCopy(    (BIT8 *)Pneu_Messages[  0], line2 );
                            StrCopy(    (BIT8 *)Pneu_Messages[  0], line3 );
                            StrCopy(    (BIT8 *)Pneu_Messages[  0], line4 );
                            BuildStringImage( line1, line2, line3, line4 );
#endif
                            break;
         case Test_Regs:
#ifdef INCLUDE_PNEU_TEST
                            DisplayTestRegs();
#else
                            StrCopy(    (BIT8 *)Pneu_Messages[276], line1 );
                            StrCopy(    (BIT8 *)Pneu_Messages[  0], line2 );
                            StrCopy(    (BIT8 *)Pneu_Messages[  0], line3 );
                            StrCopy(    (BIT8 *)Pneu_Messages[  0], line4 );
                            BuildStringImage( line1, line2, line3, line4 );
#endif
                            break;

         default: ;
     }
}

